相關(guān)分析請(qǐng)看上一篇文章：
http://www.reibang.com/p/cedfe72be146

上篇文章中最后說(shuō)到，針對(duì)于軌跡過(guò)長(zhǎng)的數(shù)據(jù)米奸，解決方案在渲染方面還是比較乏力毙籽，存在卡頓的問(wèn)題役首，本文就對(duì)此情況進(jìn)行優(yōu)化步绸。

還是先看效果：

7月-13-2017 21-22-47.gif

其實(shí)相較于之前的解決方案改動(dòng)不大室抽，大體原理就是創(chuàng)建一個(gè)Bitmap，每次刷新畫(huà)布的時(shí)候靡努，不用去遍歷所有的數(shù)據(jù)繪制，將已經(jīng)畫(huà)過(guò)的path的狀態(tài)保存在Bitmap晓折，只需要繪制動(dòng)畫(huà)執(zhí)行進(jìn)度對(duì)應(yīng)的path和之前的Bitmap即可惑朦。

還是直接看代碼會(huì)比較清晰
（RecordPathAnimUtil工具類(lèi)就不貼了，上篇文章中有漓概，沒(méi)有什么變動(dòng)）

package com.lemon.running.ui.view;

import android.animation.Animator;
import android.animation.TypeEvaluator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;

import com.lemon.running.R;
import com.lemon.running.utils.RecordPathAnimUtil;

import java.util.ArrayList;

/**
 * Created by viva on 17/6/20.
 */
public class RecordPathView extends View {

    private Context context;
    private Paint paint, iconPaint;
    private Path dstPath, totalPath;
    private PathMeasure mPathMeasure, mDstPathMeasure;

    private boolean isDrawRecordPath = false;

    private float pathLength;

    private Bitmap startIcon, middleIcon;

    private Bitmap bitmap;//當(dāng)前canvas生成的bitmap
    private Canvas bitmapCanvas;

    private float[] pathStartPoint = new float[2];
    private float[] pathEndPoint = new float[2];
    private float[] dstPathEndPoint = new float[2];

    private float value = 0;

    private long ANIM_DURATION;

    private ArrayList<RecordPathAnimUtil.RecordPathBean> recordPathList;

    private OnAnimEnd onAnimEnd;

    private int animIndex, lastAnimIndex;

    public RecordPathView(Context context) {
        super(context);
        this.context = context;
        init();
    }

    public RecordPathView(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.context = context;
        init();
    }

    public RecordPathView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        this.context = context;
        init();
    }

    private void init() {
        paint = new Paint();
        paint.setAntiAlias(true);
        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeWidth(10);

        iconPaint = new Paint();
        iconPaint.setAntiAlias(true);

        dstPath = new Path();

        startIcon = BitmapFactory.decodeResource(context.getResources(), R.drawable.outside_run_record_start_point);
        middleIcon = BitmapFactory.decodeResource(context.getResources(), R.drawable.speed_view_point);
    }

    public void setPath(RecordPathAnimUtil recordPathAnimUtil) {
        if (recordPathAnimUtil == null)
            return;
        if (!isDrawRecordPath) {
            pathLength = recordPathAnimUtil.getAllPathLength();
            ANIM_DURATION = recordPathAnimUtil.getANIM_DURATION();
            recordPathList = recordPathAnimUtil.getRecordPathList();
            totalPath = recordPathAnimUtil.getTotalPath();
            mPathMeasure = new PathMeasure(totalPath, false);
            mPathMeasure.getPosTan(0, pathStartPoint, null);//軌跡的起點(diǎn)
            mPathMeasure.getPosTan(mPathMeasure.getLength(), pathEndPoint, null);//軌跡的終點(diǎn)
            if (recordPathList == null || recordPathList.size() == 0)
                return;
            startPathAnim();
            isDrawRecordPath = true;
        }
    }

    public void setOnAnimEnd(OnAnimEnd onAnimEnd) {
        this.onAnimEnd = onAnimEnd;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (recordPathList == null || recordPathList.size() == 0)
            return;
        if (value >= 1)
            return;
        if (bitmap == null) {
            bitmap = Bitmap.createBitmap(this.getMeasuredWidth(), this.getMeasuredHeight(), Bitmap.Config.ARGB_8888);
            bitmapCanvas = new Canvas(bitmap);
        }

        bitmapCanvas.save();
        if (animIndex > lastAnimIndex && lastAnimIndex > 0) {//動(dòng)畫(huà)跳到下一段或下幾段path
            for (int i = lastAnimIndex - 1; i < animIndex; i++) {
                RecordPathAnimUtil.RecordPathBean recordPathBean = recordPathList.get(i);
                paint.setColor(recordPathBean.getEndColor());
                paint.setShader(recordPathBean.getShader());
                paint.setStrokeWidth(10);
                paint.setStyle(Paint.Style.STROKE);
                bitmapCanvas.drawPath(recordPathBean.getPath(), paint);
                paint.setShader(null);
                paint.setStrokeWidth(1);
                paint.setStyle(Paint.Style.FILL_AND_STROKE);
                bitmapCanvas.drawCircle(recordPathBean.getEndPoint().x, recordPathBean.getEndPoint().y, 5, paint);
            }
        }
        bitmapCanvas.restore();
        canvas.drawBitmap(bitmap, 0, 0, iconPaint);

        paint.setStyle(Paint.Style.STROKE);
        paint.setShader(recordPathList.get(animIndex).getShader());
        paint.setStrokeWidth(10);
        canvas.drawPath(dstPath, paint);

        canvas.drawBitmap(startIcon, pathStartPoint[0] - startIcon.getWidth() / 2, pathStartPoint[1] - startIcon.getHeight() / 2, iconPaint);
        canvas.drawBitmap(middleIcon, dstPathEndPoint[0] - middleIcon.getWidth() / 2, dstPathEndPoint[1] - middleIcon.getHeight() / 2, iconPaint);

        if (lastAnimIndex != animIndex)
            lastAnimIndex = animIndex;
    }

    /**
     * 當(dāng)前動(dòng)畫(huà)執(zhí)行進(jìn)度對(duì)應(yīng)的分段path index
     */
    private void caculateAnimPathData() {
        float length = value * pathLength;
        float caculateLength = 0;
        float offsetLength = 0;
        for (int i = 0, count = recordPathList.size(); i < count; i++) {
            caculateLength += recordPathList.get(i).getPathLength();
            if (caculateLength > length) {
                animIndex = i;
                offsetLength = caculateLength - length;
                break;
            }
        }
        dstPath.reset();
        PathMeasure pathMeasure = new PathMeasure(recordPathList.get(animIndex).getPath(), false);
        pathMeasure.getSegment(0, recordPathList.get(animIndex).getPathLength() - offsetLength, dstPath, true);
        mDstPathMeasure = new PathMeasure(dstPath, false);
        mDstPathMeasure.getPosTan(mDstPathMeasure.getLength(), dstPathEndPoint, null);
    }

    private void startPathAnim() {
        ValueAnimator animator = ValueAnimator.ofObject(new DstPathEvaluator(), 0, mPathMeasure.getLength());
        animator.setDuration(ANIM_DURATION);
        animator.setInterpolator(new AccelerateDecelerateInterpolator());
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                value = (float) animation.getAnimatedValue();
                caculateAnimPathData();
                invalidate();
            }
        });
        animator.addListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                if (onAnimEnd != null)
                    onAnimEnd.animEndCallback();
            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
        animator.start();
    }

    class DstPathEvaluator implements TypeEvaluator {

        @Override
        public Object evaluate(float fraction, Object startValue, Object endValue) {
            return fraction;
        }
    }

    public interface OnAnimEnd {
        void animEndCallback();
    }

    float x, y;

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                x = event.getX();
                y = event.getY();
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_MOVE:
            case MotionEvent.ACTION_CANCEL:
                if (Math.abs(event.getX() - x) > 0 || Math.abs(event.getY() - y) > 0) {
                    if (onAnimEnd != null)
                        onAnimEnd.animEndCallback();
                }
                break;
            default:
                break;
        }
        return true;
    }
}

注：數(shù)據(jù)量太大導(dǎo)致前期加載時(shí)間太長(zhǎng)漾月，這可以根據(jù)需求加loading，至于渲染后與地圖上的軌跡重疊胃珍，這也很好解決梁肿，不再贅述。

繼續(xù)廣告

5322402-764c9ac6a1721316.jpeg