PathView plays

package com.eftimoff.empty;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.graphics.RectF;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;

import com.nineoldandroids.animation.Animator;
import com.nineoldandroids.animation.AnimatorSet;
import com.nineoldandroids.animation.ObjectAnimator;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class SplashView extends View {

    private Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    private static final float OVAL_RADIUS = 8.0f;

    private final Object mSvgLock = new Object();
    private PathMeasure measure, disappearMeasure;
    Handler handler;
    Random random;
    boolean first = false;
    int screenWidth, screenHeight;
    float endX, endY;
    float startX, startY, firstStartX, firstStartY;
    float currentLength, disappearLength;
    int index, disappearIndex = -1;
    private LinkedList<Path> paths = new LinkedList<>();

    public SplashView(Context context) {
        super(context);
        init();
    }

    public SplashView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public SplashView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private void init() {
        random = new Random();
        handler = new Handler();

        setDrawingCacheEnabled(true);
        paint.setColor(getResources().getColor(R.color.white_transparent));
        paint.setStyle(Paint.Style.STROKE);
        paint.setStrokeJoin(Paint.Join.ROUND);
        paint.setStrokeCap(Paint.Cap.ROUND);
        paint.setStrokeWidth(8.0f);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        screenHeight = h;
        screenWidth = w;

        firstStartX = startX = random.nextInt(screenWidth);
        firstStartY = startY = random.nextInt(screenHeight);

        first = true;
        handler.postDelayed(runnable, 1500);
    }

    private Runnable runnable = new Runnable() {
        @Override
        public void run() {
            synchronized (mSvgLock) {
                random = new Random();

//                if (disappearIndex != -1) {
//                    paths.remove(disappearIndex);
//                    disappearIndex = -1;
//                    disappearLength = 0.0f;
//                    disappearMeasure = null;
//                }

                if (paths.size() == 6) {
                    endX = firstStartX;
                    endY = firstStartY;
                }  else {
                    endX = random.nextInt(screenWidth);
                    endY = random.nextInt(screenHeight);
                }

                Path mPath = drawSegment(startX, startY, endX, endY, first);
                paths.add(mPath);
                first = false;

                index = paths.size() - 1;
                if ((paths.size() % 3 == 0) && paths.size() > 10) {
                    random = new Random();
                    disappearIndex = random.nextInt(paths.size());
                    while (disappearIndex == index) {
                        random = new Random();
                        disappearIndex = random.nextInt(paths.size());
                        if (disappearIndex != index)
                            break;
                    }
                } else {
                    disappearIndex = -1;
                }

                measure = new PathMeasure(mPath, false);
                currentLength = measure.getLength();

                if (disappearIndex != -1) {
                    disappearMeasure = new PathMeasure(paths.get(disappearIndex), false);
                    disappearLength = disappearMeasure.getLength();
                }

                startX = endX;
                startY = endY;

                AnimatorSet set = new AnimatorSet();
                set.setInterpolator(new AccelerateDecelerateInterpolator());
                set.addListener(new Animator.AnimatorListener() {
                    @Override
                    public void onAnimationStart(Animator animation) {

                    }

                    @Override
                    public void onAnimationEnd(Animator animation) {
//                        handler.post(runnable);
                    }

                    @Override
                    public void onAnimationCancel(Animator animation) {

                    }

                    @Override
                    public void onAnimationRepeat(Animator animation) {

                    }
                });

                ObjectAnimator animator = ObjectAnimator.ofFloat(SplashView.this, "phase", 0.0f, 1.0f);
                animator.setDuration(1500);
                ObjectAnimator disappearAnimator = ObjectAnimator.ofFloat(SplashView.this, "phase", 1.0f, 0.0f);
                disappearAnimator.setDuration(1500);

                List<Animator> animatorList = new ArrayList<>();
                animatorList.add(animator);
                if (disappearIndex != -1) {
                    animatorList.add(disappearAnimator);
                }

                set.playTogether(animatorList);
                set.start();
            }
        }
    };

    private Path drawSegment(float x1, float y1, float x2, float y2, boolean first) {
        final Path path = new Path();
        path.moveTo(x1, y1);
        path.lineTo(x2, y2);

        RectF mOval = new RectF(x2 - OVAL_RADIUS, y2 - OVAL_RADIUS, x2 + OVAL_RADIUS, y2 + OVAL_RADIUS);
        path.arcTo(mOval, 0, 359);
        path.addArc(mOval, 0, 360);

//        if (first) {
//            path.moveTo(x1, y1);
//            RectF mOvalFirst = new RectF(x1 - OVAL_RADIUS, y1 - OVAL_RADIUS, x1 + OVAL_RADIUS, y1 + OVAL_RADIUS);
//            path.arcTo(mOvalFirst, 0, 359);
//            path.addArc(mOvalFirst, 0, 360);
//        }

        path.close();

        return path;
    }

    public void setPhase(float phase) {
        Path mPath = new Path();
        measure.getSegment(0.0f, currentLength * phase, mPath, true);
        synchronized (mSvgLock) {
            paths.set(index, mPath);
        }

        if (disappearIndex != -1) {
            mPath.reset();

            disappearMeasure.getSegment(0.0f, disappearLength * phase, mPath, true);
            synchronized (mSvgLock) {
                paths.set(disappearIndex, mPath);
            }
        }
        invalidate();//will calll onDraw
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

//        mCanvas.drawColor(Color.BLACK);

        synchronized (mSvgLock) {
            for (Path p : paths) {
                canvas.drawPath(p, paint);
            }
        }
//        mCanvas.drawPath(mPath, paint);
////        mCanvas.drawPath(mPath, paint);
//        canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint);
//        canvas.drawPath(currentPath, paint);
    }
}