简陋的冰桶挑战小游戏

package com.github.c.game;

import android.animation.ObjectAnimator;
import android.animation.TimeInterpolator;
import android.animation.ValueAnimator;
import android.os.Build;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.view.animation.LinearInterpolator;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;

/**
 * 知识点：
 * 属性动画ObjectAnimator的应用
 * api19以下动画如何暂停和恢复
 * api19以上可以直接使用自带的pause、resume
 */
public class MainActivity extends AppCompatActivity {

    public static final String TAG = "MainActivity";
    private RelativeLayout rl;
    private ImageView mImgTong;
    private ImageView mImgRen;
    private TextView mTvScore;
    private boolean isMoving = false;
    private ObjectAnimator moveAnimator;
    private ObjectAnimator dropTongAnimator;
    private ObjectAnimator initTongTongAnimator;
    private View line;
    private MyAnimatorUpdateListener updateListener = new MyAnimatorUpdateListener();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        setListener();

    }

    private void setListener() {

        rl.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (isMoving) {
//                    冰桶向下，倒下冰块
                    dropTong();
//                    冰桶停止运动
                    stopMove();
//                    根据冰块落下的X轴坐标，计算出得分，并显示得分
                    showScore();
                    isMoving = false;
                } else {
//                    冰桶向上，装满冰块
                    initTong();
//                    冰桶开始动起来
                    startMove();
                    isMoving = true;
                }
            }

        });
    }

    private void showScore() {
        float score = caculateScore();
        Log.e(TAG, "显示得分");
        mTvScore.setText(String.format("%.2f", score));
    }

    float halfScreenWidth = 540f;

    private float caculateScore() {
        Log.e(TAG, "根据冰块落下的X轴坐标，计算出得分");
        float score = 50;
        float stopTranslationX = mImgTong.getTranslationX();
        float offX = Math.abs(stopTranslationX);
        score = (float) (100 - (offX / (halfScreenWidth * 0.01)));

        return score;
    }

    private void initTong() {
        Log.e(TAG, "冰桶向上，装满冰块");
        mImgTong.setRotation(0);
//        initTongAnimate();
    }

    private void dropTong() {
        Log.e(TAG, "冰桶向下，倒下冰块");
        mImgTong.setRotation(180f);
//        dropTongAnimate();

    }


    private void startMove() {
        Log.e(TAG, "冰桶开始动起来");
        float curTranslationX = mImgTong.getTranslationX();
        line.setVisibility(View.GONE);
        if (moveAnimator == null) {
            moveAnimator = ObjectAnimator.ofFloat(mImgTong, "translationX", curTranslationX, -halfScreenWidth, halfScreenWidth, curTranslationX);
            moveAnimator.setDuration(5000);
            moveAnimator.setInterpolator(new LinearInterpolator());
            moveAnimator.setRepeatCount(ValueAnimator.INFINITE);
            Log.e(TAG, curTranslationX + "");
            moveAnimator.start();
            moveAnimator.addUpdateListener(updateListener);
        } else {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                moveAnimator.resume();//api19以上才能用
            } else {//api19以下使用
                if (updateListener.isPause) {
                    updateListener.play();
                }
            }
        }

    }

    private void stopMove() {
//        moveAnimator.cancel();//使用cancle效果不好
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            moveAnimator.pause();//api19以上才能用
        } else {//api19以下使用
            updateListener.pause();
        }

        line.setTranslationX(mImgTong.getTranslationX());
        line.setVisibility(View.VISIBLE);
        Log.e(TAG, "冰桶停止运动");
    }

    private void initView() {
        rl = (RelativeLayout) findViewById(R.id.rl);
        mImgTong = (ImageView) findViewById(R.id.iv_tong);
        mImgRen = (ImageView) findViewById(R.id.iv_ren);
        mTvScore = (TextView) findViewById(R.id.tv_score);
        line =  findViewById(R.id.line);
    }


    private void initTongAnimate() {
        initTongTongAnimator = ObjectAnimator.ofFloat(mImgTong, "rotationX", 180f, 0f);
        initTongTongAnimator.setDuration(100);
        initTongTongAnimator.setInterpolator(new LinearInterpolator());
        initTongTongAnimator.start();
    }

    private void dropTongAnimate() {
        dropTongAnimator = ObjectAnimator.ofFloat(mImgTong, "rotationX", 0, 180f);
        dropTongAnimator.setDuration(100);
        dropTongAnimator.setInterpolator(new LinearInterpolator());
        dropTongAnimator.start();
    }


    class MyAnimatorUpdateListener implements ValueAnimator.AnimatorUpdateListener {
        /**
         * 暂停状态
         */
        private boolean isPause = false;
        /**
         * 是否已经暂停，如果一已经暂停，那么就不需要再次设置停止的一些事件和监听器了
         */
        private boolean isPaused = false;
        /**
         * 当前的动画的播放位置
         */
        private float fraction = 0.0f;
        /**
         * 当前动画的播放运行时间
         */
        private long mCurrentPlayTime = 0l;

        /**
         * 是否是暂停状态
         *
         * @return
         */
        public boolean isPause() {
            return isPause;
        }

        /**
         * 停止方法，只是设置标志位，剩余的工作会根据状态位置在onAnimationUpdate进行操作
         */
        public void pause() {
            isPause = true;
        }

        public void play() {
            isPause = false;
            isPaused = false;
        }

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            /**
             * 如果是暂停则将状态保持下来，并每个刷新动画的时间了；来设置当前时间，让动画
             * 在时间上处于暂停状态，同时要设置一个静止的时间加速器，来保证动画不会抖动
             */
            if (isPause) {
                if (!isPaused) {
                    mCurrentPlayTime = animation.getCurrentPlayTime();
                    fraction = animation.getAnimatedFraction();
                    animation.setInterpolator(new TimeInterpolator() {
                        @Override
                        public float getInterpolation(float input) {
                            return fraction;
                        }
                    });
                    isPaused = true;
                }
                //每隔动画播放的时间，我们都会将播放时间往回调整，以便重新播放的时候接着使用这个时间,同时也为了让整个动画不结束
                new CountDownTimer(ValueAnimator.getFrameDelay(), ValueAnimator.getFrameDelay()) {

                    @Override
                    public void onTick(long millisUntilFinished) {
                    }

                    @Override
                    public void onFinish() {
                        moveAnimator.setCurrentPlayTime(mCurrentPlayTime);
                    }
                }.start();
            } else {
                //将时间拦截器恢复成线性的，如果您有自己的，也可以在这里进行恢复
                animation.setInterpolator(null);
            }
        }

    }
}