java类android.view.animation.PathInterpolator的实例源码

@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
@OnClick({R.id.bezier, R.id.go})
public void onClick(View view) {
    switch (view.getId()) {
        case R.id.bezier:
            Intent intent = new Intent(InterpolatorPathActivity.this, BrizerActivity.class);
            startActivity(intent);
            break;
        case R.id.go:
            Path path = new Path();
            path.moveTo(X, Y);
            path.quadTo(800, Y, 800, 800);
            ObjectAnimator objectAnimator1 = new ObjectAnimator().ofFloat(image, "x", "y", path);
            objectAnimator1.setDuration(3000);
            objectAnimator1.setInterpolator(new PathInterpolator(0.9f, 0.1f, 0.5f, 0.9f));

            objectAnimator1.start();
            break;
    }
}

private void animateNavigationBarColor(int color) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        if (navigationBarColorAnimator != null) navigationBarColorAnimator.cancel();
        navigationBarColorAnimator = ValueAnimator
                .ofArgb(getWindow().getNavigationBarColor(), color)
                .setDuration(ViewUtil.PHONOGRAPH_ANIM_TIME);
        navigationBarColorAnimator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
        navigationBarColorAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @TargetApi(Build.VERSION_CODES.LOLLIPOP)
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                AbsSlidingMusicPanelActivity.super.setNavigationbarColor((Integer) animation.getAnimatedValue());
            }
        });
        navigationBarColorAnimator.start();
    }
}

private void curved(){
    Path path = new Path();
    //path.moveTo(view.getX(), view.getY());
    //path.lineTo(200, 200);
    //path.lineTo(600, 600);
    //path.arcTo(r,0,180,false);
    //path.rQuadTo(500,300,300,700);
    //path.cubicTo(100,100,500,300,300,700);
    //path.rCubicTo(100,100,500,300,300,700);
    //path.addArc(100,100,1000,700,-180,180);
    //path.cubicTo(100,100,200,200,300,300);
    path.moveTo(100,100);
    path.quadTo(1000,300,300,700);


    ObjectAnimator mAnimator = ObjectAnimator.ofFloat(curved, View.X, View.Y, path);

    Path p = new Path();
    p.lineTo(0.6f, 0.9f);
    p.lineTo(0.75f, 0.2f);
    p.lineTo(1f, 1f);
    mAnimator.setInterpolator(new PathInterpolator(p));

    mAnimator.setDuration(3000);
    mAnimator.start();
}

@Test
public void validateSetOfObjectAnimatorAlphaMotionTiming() {
  MotionSpec spec =
      MotionSpec.createFromResource(
          activityTestRule.getActivity(), R.animator.valid_set_of_object_animator_motion_spec);
  MotionTiming alpha = spec.getTiming("alpha");

  assertEquals(3, alpha.getDelay());
  assertEquals(5, alpha.getDuration());
  if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
    assertThat(alpha.getInterpolator(), instanceOf(PathInterpolator.class));
  } else {
    assertThat(alpha.getInterpolator(), instanceOf(FastOutLinearInInterpolator.class));
  }
  assertEquals(7, alpha.getRepeatCount());
  assertEquals(ValueAnimator.RESTART, alpha.getRepeatMode());
}

@Test
public void validateSetOfObjectAnimatorTranslationMotionTiming() {
  MotionSpec spec =
      MotionSpec.createFromResource(
          activityTestRule.getActivity(), R.animator.valid_set_of_object_animator_motion_spec);
  MotionTiming translation = spec.getTiming("translation");

  assertEquals(11, translation.getDelay());
  assertEquals(13, translation.getDuration());
  if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP) {
    assertThat(translation.getInterpolator(), instanceOf(PathInterpolator.class));
  } else {
    assertThat(translation.getInterpolator(), instanceOf(FastOutSlowInInterpolator.class));
  }
  assertEquals(17, translation.getRepeatCount());
  assertEquals(ValueAnimator.REVERSE, translation.getRepeatMode());
}

private Interpolator getInterpolator(float startGradient, float velocityFactor) {
    if (startGradient != mCachedStartGradient
            || velocityFactor != mCachedVelocityFactor) {
        float speedup = mSpeedUpFactor * (1.0f - velocityFactor);
        mInterpolator = new PathInterpolator(speedup,
                speedup * startGradient,
                mLinearOutSlowInX2, mY2);
        mCachedStartGradient = startGradient;
        mCachedVelocityFactor = velocityFactor;
    }
    return mInterpolator;
}

private AnimatorProperties getDismissingProperties(float currValue, float endValue,
        float velocity, float maxDistance) {
    float maxLengthSeconds = (float) (mMaxLengthSeconds
            * Math.pow(Math.abs(endValue - currValue) / maxDistance, 0.5f));
    float diff = Math.abs(endValue - currValue);
    float velAbs = Math.abs(velocity);
    float y2 = calculateLinearOutFasterInY2(velAbs);

    float startGradient = y2 / LINEAR_OUT_FASTER_IN_X2;
    Interpolator mLinearOutFasterIn = new PathInterpolator(0, 0, LINEAR_OUT_FASTER_IN_X2, y2);
    float durationSeconds = startGradient * diff / velAbs;
    if (durationSeconds <= maxLengthSeconds) {
        mAnimatorProperties.interpolator = mLinearOutFasterIn;
    } else if (velAbs >= mMinVelocityPxPerSecond) {

        // Cross fade between linear-out-faster-in and linear interpolator with current
        // velocity.
        durationSeconds = maxLengthSeconds;
        VelocityInterpolator velocityInterpolator
                = new VelocityInterpolator(durationSeconds, velAbs, diff);
        InterpolatorInterpolator superInterpolator = new InterpolatorInterpolator(
                velocityInterpolator, mLinearOutFasterIn, Interpolators.LINEAR_OUT_SLOW_IN);
        mAnimatorProperties.interpolator = superInterpolator;
    } else {

        // Just use a normal interpolator which doesn't take the velocity into account.
        durationSeconds = maxLengthSeconds;
        mAnimatorProperties.interpolator = Interpolators.FAST_OUT_LINEAR_IN;
    }
    mAnimatorProperties.duration = (long) (durationSeconds * 1000);
    return mAnimatorProperties;
}

private static Animator createColorAnimator(Object target, String propertyName, @ColorInt int startColor, @ColorInt int endColor) {
    ObjectAnimator animator;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        animator = ObjectAnimator.ofArgb(target, propertyName, startColor, endColor);
    } else {
        animator = ObjectAnimator.ofInt(target, propertyName, startColor, endColor);
        animator.setEvaluator(new ArgbEvaluator());
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        animator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
    }
    animator.setDuration(PHONOGRAPH_ANIM_TIME);
    return animator;
}

public static Interpolator create(
    float controlX1, float controlY1, float controlX2, float controlY2) {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    return new PathInterpolator(controlX1, controlY1, controlX2, controlY2);
  }
  return new PathInterpolatorBase(controlX1, controlY1, controlX2, controlY2);
}

private void animateNavigationBarColor(int color) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        if (navigationBarColorAnimator != null) navigationBarColorAnimator.cancel();
        navigationBarColorAnimator = ValueAnimator.ofArgb(getWindow().getNavigationBarColor(), color).setDuration(ViewUtil.RETRO_MUSIC_ANIM_TIME);
        navigationBarColorAnimator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
        navigationBarColorAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @TargetApi(Build.VERSION_CODES.LOLLIPOP)
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                AbsSlidingMusicPanelActivity.super.setNavigationbarColor((Integer) animation.getAnimatedValue());
            }
        });
        navigationBarColorAnimator.start();
    }
}

private static int[] getOutputPointsForNewerDevices(Point[] knots) {

        Point[] controlPoints = calculateControlPoints(knots);
        Path path = new Path();
        path.moveTo(0, 0);
        path.lineTo(knots[0].x / 255.0f, knots[0].y / 255.0f);
        path.moveTo(knots[0].x / 255.0f, knots[0].y / 255.0f);

        for (int index = 1; index < knots.length; index++) {
            path.quadTo(
                    controlPoints[index - 1].x / 255.0f,
                    controlPoints[index - 1].y / 255.0f,
                    knots[index].x / 255.0f,
                    knots[index].y / 255.0f
            );
            path.moveTo(knots[index].x / 255.0f, knots[index].y / 255.0f);
        }

        path.lineTo(1, 1);
        path.moveTo(1, 1);

        float[] allPoints = new float[256];

        for (int x = 0; x < 256; x++) {
            PathInterpolator pathInterpolator = new PathInterpolator(path);
            allPoints[x] = 255.0f * pathInterpolator.getInterpolation((float) x / 255.0f);
        }

        allPoints[0] = knots[0].y;
        allPoints[255] = knots[knots.length - 1].y;
        return validateCurve(allPoints);
    }

private static int[] getOutputPointsForNewerDevices(Point[] knots) {

        Point[] controlPoints = calculateControlPoints(knots);
        Path path = new Path();
        path.moveTo(0, 0);
        path.lineTo(knots[0].x / 255.0f, knots[0].y / 255.0f);
        path.moveTo(knots[0].x / 255.0f, knots[0].y / 255.0f);

        for (int index = 1; index < knots.length; index++) {
            path.quadTo(
                    controlPoints[index - 1].x / 255.0f,
                    controlPoints[index - 1].y / 255.0f,
                    knots[index].x / 255.0f,
                    knots[index].y / 255.0f
            );
            path.moveTo(knots[index].x / 255.0f, knots[index].y / 255.0f);
        }

        path.lineTo(1, 1);
        path.moveTo(1, 1);

        float[] allPoints = new float[256];

        for (int x = 0; x < 256; x++) {
            PathInterpolator pathInterpolator = new PathInterpolator(path);
            allPoints[x] = 255.0f * pathInterpolator.getInterpolation((float) x / 255.0f);
        }

        allPoints[0] = knots[0].y;
        allPoints[255] = knots[knots.length - 1].y;
        return validateCurve(allPoints);
    }

private void init(Context context, AttributeSet attributeSet) {
    if (Build.VERSION.SDK_INT >= 21) {
        mInterpolator = new PathInterpolator(0.33f, 0f, 0.33f, 1);
    } else {
        mInterpolator = new AccelerateDecelerateInterpolator();
    }
    mShadowDrawable = getResources().getDrawable(R.drawable.gradient_layout_shadow);
    mDensity = getResources().getDisplayMetrics().density;
}

private void animateNavigationBarColor(int color) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        if (navigationBarColorAnimator != null) navigationBarColorAnimator.cancel();
        navigationBarColorAnimator = ValueAnimator
                .ofArgb(getWindow().getNavigationBarColor(), color)
                .setDuration(ViewUtil.PHONOGRAPH_ANIM_TIME);
        navigationBarColorAnimator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
        navigationBarColorAnimator.addUpdateListener(animation -> AbsSlidingMusicPanelActivity.super.setNavigationbarColor((Integer) animation.getAnimatedValue()));
        navigationBarColorAnimator.start();
    }
}

private static Animator createColorAnimator(Object target, String propertyName, @ColorInt int startColor, @ColorInt int endColor) {
    ObjectAnimator animator;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        animator = ObjectAnimator.ofArgb(target, propertyName, startColor, endColor);
    } else {
        animator = ObjectAnimator.ofInt(target, propertyName, startColor, endColor);
        animator.setEvaluator(new ArgbEvaluator());
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        animator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
    }
    animator.setDuration(PHONOGRAPH_ANIM_TIME);
    return animator;
}

public LollipopView(Wrapped wrapped, boolean top) {
    this.wrapped = new WeakReference<>(wrapped);
    this.top = top;
    Path startPath = new Path();
    startPath.lineTo(0.5f, 0f);
    startPath.cubicTo(0.7f, 0f, 0.6f, 1f, 1f, 1f);
    startInterpolator = new PathInterpolator(startPath);
    Path endPath = new Path();
    endPath.cubicTo(0.2f, 0f, 0.1f, 1f, 0.5f, 1f);
    endPath.lineTo(1f, 1f);
    endInterpolator = new PathInterpolator(endPath);
    ringPaint.setStyle(Paint.Style.STROKE);
    ringPaint.setStrokeCap(Paint.Cap.SQUARE);
    ringPaint.setStrokeJoin(Paint.Join.MITER);
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public CircularProgressBar(Context context, AttributeSet attrs) {
    super(context, attrs);
    paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint.setStyle(Paint.Style.STROKE);
    paint.setStrokeCap(Paint.Cap.SQUARE);
    paint.setStrokeJoin(Paint.Join.MITER);
    if (C.API_LOLLIPOP) {
        Path startPath = new Path();
        startPath.lineTo(0.5f, 0f);
        startPath.cubicTo(0.7f, 0f, 0.6f, 1f, 1f, 1f);
        lollipopStartInterpolator = new PathInterpolator(startPath);
        Path endPath = new Path();
        endPath.cubicTo(0.2f, 0f, 0.1f, 1f, 0.5f, 1f);
        endPath.lineTo(1f, 1f);
        lollipopEndInterpolator = new PathInterpolator(endPath);
        indeterminateDrawable = null;
        indeterminateDuration = 0;
    } else {
        lollipopStartInterpolator = null;
        lollipopEndInterpolator = null;
        TypedArray typedArray = context.obtainStyledAttributes(android.R.style.Widget_Holo_ProgressBar_Large,
                new int[] {android.R.attr.indeterminateDrawable, android.R.attr.indeterminateDuration});
        indeterminateDrawable = typedArray.getDrawable(0);
        indeterminateDuration = typedArray.getInteger(1, 3500);
        typedArray.recycle();
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void animateViewColor(View v, int startColor, int endColor) {

    ObjectAnimator animator = ObjectAnimator.ofObject(v, "backgroundColor",
            new ArgbEvaluator(), startColor, endColor);

    animator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
    animator.setDuration(COLOR_ANIMATION_DURATION);
    animator.start();
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static void animateViewColor(View v, int startColor, int endColor) {

    ObjectAnimator animator = ObjectAnimator.ofObject(v, "backgroundColor",
            new ArgbEvaluator(), startColor, endColor);

    animator.setInterpolator(new PathInterpolator(0.4f, 0f, 1f, 1f));
    animator.setDuration(COLOR_ANIMATION_DURATION);
    animator.start();
}

public static Interpolator create(Path path) {
    return new PathInterpolator(path);
}

public static Interpolator create(float controlX, float controlY) {
    return new PathInterpolator(controlX, controlY);
}

public static Interpolator create(float controlX1, float controlY1,
        float controlX2, float controlY2) {
    return new PathInterpolator(controlX1, controlY1, controlX2, controlY2);
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Interpolator create(Path path) {
    return new PathInterpolator(path);
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Interpolator create(float controlX, float controlY) {
    return new PathInterpolator(controlX, controlY);
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static Interpolator create(float controlX1, float controlY1,
                                  float controlX2, float controlY2) {
    return new PathInterpolator(controlX1, controlY1, controlX2, controlY2);
}

public static Interpolator create(Path path) {
    return new PathInterpolator(path);
}

public static Interpolator create(float controlX, float controlY) {
    return new PathInterpolator(controlX, controlY);
}

public static Interpolator create(float controlX1, float controlY1, float controlX2, float controlY2) {
    return new PathInterpolator(controlX1, controlY1, controlX2, controlY2);
}

public static Interpolator create(Path path) {
    return new PathInterpolator(path);
}

public static Interpolator create(float controlX, float controlY) {
    return new PathInterpolator(controlX, controlY);
}