Java 类android.animation.TimeInterpolator 实例源码

private void startTranslatePlayListAnim(float from, float to, int duration, final View view, @Nullable TimeInterpolator interpolator, @Nullable Animator.AnimatorListener listener) {
    final ValueAnimator anim = ObjectAnimator.ofFloat(from, to);
    anim.setDuration(duration);
    if (interpolator != null)
        anim.setInterpolator(interpolator);
    anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            float va = (float) animation.getAnimatedValue();
            view.setY(va);
        }
    });
    if (listener != null) {
        anim.addListener(listener);
    }
    anim.start();
}

@Override
public void onAnimationUpdate(ValueAnimator animation) {
  if (view.getLayoutParams() != null) {
    ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
    TimeInterpolator interpolator = animation.getInterpolator();
    float fraction = animation.getAnimatedFraction();
    if (width != null) {
      layoutParams.width = intEvaluator.evaluate(interpolator.getInterpolation(fraction),
                                                 width.first,
                                                 width.second);
    }
    if (height != null) {
      layoutParams.height = intEvaluator.evaluate(interpolator.getInterpolation(fraction),
                                                  height.first,
                                                  height.second);
    }
    view.requestLayout();
  }
}

private TimeInterpolator getTimeInterpolater() {
    switch (mAnimationStyle) {
        case ViewBaseCommon.ANIMATION_LINEAR:
            return new LinearInterpolator();
        case ViewBaseCommon.ANIMATION_DECELERATE:
            return new DecelerateInterpolator();
        case ViewBaseCommon.ANIMATION_ACCELERATE:
            return new AccelerateInterpolator();
        case ViewBaseCommon.ANIMATION_ACCELERATEDECELERATE:
            return new AccelerateDecelerateInterpolator();
        case ViewBaseCommon.ANIMATION_SPRING:
            return new SpringInterpolator();
        default:
            return new LinearInterpolator();
    }
}

@Override
public void prepareAnimators(DepthRelativeLayout target, int index, int animationDelay) {
    final TimeInterpolator interpolator = new ExpoIn();

    final float finalTranslationY = exitConfiguration.getFinalYPercent() * target.getResources().getDisplayMetrics().heightPixels;
    final float finalTranslationX = exitConfiguration.getFinalXPercent() * target.getResources().getDisplayMetrics().widthPixels;

    final long totalDuration = exitConfiguration.getDuration();

    final ObjectAnimator translationY2 = ObjectAnimator.ofFloat(target, View.TRANSLATION_Y, finalTranslationY);
    translationY2.setDuration(totalDuration);
    //translationY2.setInterpolator(new AccelerateInterpolator());
    translationY2.setInterpolator(interpolator);
    translationY2.setStartDelay(animationDelay);
    attachListener(translationY2);
    add(translationY2);

    final ObjectAnimator translationX2 = ObjectAnimator.ofFloat(target, View.TRANSLATION_X, finalTranslationX);
    translationX2.setDuration(totalDuration);
    translationX2.setInterpolator(interpolator);
    translationX2.setStartDelay(animationDelay);
    add(translationX2);
}

@Test
public void preparePartialTransition_setsPartialInterpolator() {
    //given
    final StaggeredAnimationGroup spiedGroup = prepareSpiedGroup();
    final TimeInterpolator testInterpolator = new LinearOutSlowInInterpolator();
    final Transition spiedTransition = spy(new AutoTransition());
    final StaggeredAnimationGroup.PartialTransitionFactory factory =
            new StaggeredAnimationGroup.PartialTransitionFactory() {
                @Override
                public Transition createPartialTransition(boolean show, int viewId, int indexInTransition) {
                    return spiedTransition;
                }
            };
    spiedGroup.setPartialTransitionFactory(factory);
    spiedGroup.setPartialInterpolator(testInterpolator);

    //when
    spiedGroup.preparePartialTransition(true, 0, 0);

    //then
    verify(spiedTransition, times(1)).setInterpolator(testInterpolator);
}

public T setInterpolator(TimeInterpolator interpolator) {
    if(mCurrentCustomInterpolator != null) {
        switchInterpolator(interpolator);
    } else {
        getValueAnimator().setInterpolator(interpolator);
    }
    return self();
}

/**
 * Set TimeInterpolator for all page animations.
 *
 * @param interpolator TimeInterpolator
 */
public void setTimeInterpolator(TimeInterpolator interpolator) {
    if (pageAnimations == null) return;
    for (ArrayList<PageAnimation> pageAnimationsInSamePage : pageAnimations) {
        if (pageAnimationsInSamePage == null) continue;
        for (PageAnimation pageAnimation : pageAnimationsInSamePage) pageAnimation.setTimeInterpolator(interpolator);
    }
}

private static void runExitAnimation(final Activity activity,
                                     ArrayList<EasyTransitionOptions.ViewAttrs> attrs,
                                     long duration,
                                     TimeInterpolator interpolator) {
    if (null == attrs || attrs.size() == 0)
        return;

    for (final EasyTransitionOptions.ViewAttrs attr : attrs) {
        View view = activity.findViewById(attr.id);
        int[] location = new int[2];
        view.getLocationOnScreen(location);
        view.setPivotX(0);
        view.setPivotY(0);

        view.animate()
                .scaleX(attr.width / view.getWidth())
                .scaleY(attr.height / view.getHeight())
                .translationX(attr.startX - location[0])
                .translationY(attr.startY - location[1])
                .setInterpolator(interpolator)
                .setDuration(duration);
    }

    activity.findViewById(attrs.get(0).id).postDelayed(new Runnable() {
        @Override
        public void run() {
            activity.finish();
            activity.overridePendingTransition(0, 0);
        }
    }, duration);
}

protected void snapToPage(int whichPage, int duration, boolean immediate,
        TimeInterpolator interpolator) {
    whichPage = validateNewPage(whichPage);

    int newX = getScrollForPage(whichPage);
    final int delta = newX - getUnboundedScrollX();
    snapToPage(whichPage, delta, duration, immediate, interpolator);
}

protected void snapToPage(int whichPage, int delta, int duration, boolean immediate,
        TimeInterpolator interpolator) {
    whichPage = validateNewPage(whichPage);

    mNextPage = whichPage;

    pageBeginMoving();
    awakenScrollBars(duration);
    if (immediate) {
        duration = 0;
    } else if (duration == 0) {
        duration = Math.abs(delta);
    }

    if (!mScroller.isFinished()) {
        abortScrollerAnimation(false);
    }

    if (interpolator != null) {
        mScroller.setInterpolator(interpolator);
    } else {
        mScroller.setInterpolator(mDefaultInterpolator);
    }

    mScroller.startScroll(getUnboundedScrollX(), 0, delta, 0, duration);

    updatePageIndicator();

    // Trigger a compute() to finish switching pages if necessary
    if (immediate) {
        computeScroll();
    }

    mForceScreenScrolled = true;
    invalidate();
}

protected void snapToPage(int whichPage, int duration, boolean immediate,
        TimeInterpolator interpolator) {
    whichPage = validateNewPage(whichPage);

    int newX = getScrollForPage(whichPage);
    final int delta = newX - getUnboundedScrollX();
    snapToPage(whichPage, delta, duration, immediate, interpolator);
}

protected void snapToPage(int whichPage, int delta, int duration, boolean immediate,
        TimeInterpolator interpolator) {
    whichPage = validateNewPage(whichPage);

    mNextPage = whichPage;

    awakenScrollBars(duration);
    if (immediate) {
        duration = 0;
    } else if (duration == 0) {
        duration = Math.abs(delta);
    }

    if (duration != 0) {
        pageBeginTransition();
    }

    if (!mScroller.isFinished()) {
        abortScrollerAnimation(false);
    }

    if (interpolator != null) {
        mScroller.setInterpolator(interpolator);
    } else {
        mScroller.setInterpolator(mDefaultInterpolator);
    }

    mScroller.startScroll(getUnboundedScrollX(), 0, delta, 0, duration);

    updatePageIndicator();

    // Trigger a compute() to finish switching pages if necessary
    if (immediate) {
        computeScroll();
        pageEndTransition();
    }

    invalidate();
}

private void hideTargets(boolean animate, boolean expanded) {
    mTargetAnimations.cancel();
    // Note: these animations should complete at the same time so that we can swap out
    // the target assets asynchronously from the setTargetResources() call.
    mAnimatingTargets = animate;
    final int duration = animate ? HIDE_ANIMATION_DURATION : 0;
    final int delay = animate ? HIDE_ANIMATION_DELAY : 0;

    final float targetScale = expanded ?
            TARGET_SCALE_EXPANDED : TARGET_SCALE_COLLAPSED;
    final int length = mTargetDrawables.size();
    final TimeInterpolator interpolator = Ease.Cubic.easeOut;
    for (int i = 0; i < length; i++) {
        TargetDrawable target = mTargetDrawables.get(i);
        target.setState(TargetDrawable.STATE_INACTIVE);
        mTargetAnimations.add(Tweener.to(target, duration,
                "ease", interpolator,
                "alpha", 0.0f,
                "scaleX", targetScale,
                "scaleY", targetScale,
                "delay", delay,
                "onUpdate", mUpdateListener));
    }

    float ringScaleTarget = expanded ?
            RING_SCALE_EXPANDED : RING_SCALE_COLLAPSED;
    ringScaleTarget *= mRingScaleFactor;
    mTargetAnimations.add(Tweener.to(mOuterRing, duration,
            "ease", interpolator,
            "alpha", 0.0f,
            "scaleX", ringScaleTarget,
            "scaleY", ringScaleTarget,
            "delay", delay,
            "onUpdate", mUpdateListener,
            "onComplete", mTargetUpdateListener));

    mTargetAnimations.start();
}

public static void startTranslateYAnim(float from, float to, int duration, final View view, @Nullable TimeInterpolator interpolator) {
    final ValueAnimator anim = ObjectAnimator.ofFloat(from, to);
    anim.setDuration(duration);
    if (interpolator != null)
        anim.setInterpolator(interpolator);
    anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            float va = (float) animation.getAnimatedValue();
            view.setY(va);
        }
    });
    anim.start();
}

/**
 * {@inheritDoc}
 */
@Override
public void toggle(final long duration, final @Nullable TimeInterpolator interpolator) {
    if (closePosition < getCurrentPosition()) {
        collapse(duration, interpolator);
    } else {
        expand(duration, interpolator);
    }
}

/**
 * {@inheritDoc}
 */
@Override
public void expand(final long duration, final @Nullable TimeInterpolator interpolator) {
    if (isAnimating) return;

    if (duration <= 0) {
        move(layoutSize, duration, interpolator);
        return;
    }
    createExpandAnimator(getCurrentPosition(), layoutSize, duration, interpolator).start();
}

/**
 * {@inheritDoc}
 */
@Override
public void collapse(final long duration, final @Nullable TimeInterpolator interpolator) {
    if (isAnimating) return;

    if (duration <= 0) {
        move(closePosition, duration, interpolator);
        return;
    }
    createExpandAnimator(getCurrentPosition(), closePosition, duration, interpolator).start();
}

/**
 * Creates interpolator.
 *
 * @param interpolatorType
 * @return
 */
public static TimeInterpolator createInterpolator(@IntRange(from = 0, to = 10) final int interpolatorType) {
    switch (interpolatorType) {
        case ACCELERATE_DECELERATE_INTERPOLATOR:
            return new AccelerateDecelerateInterpolator();
        case ACCELERATE_INTERPOLATOR:
            return new AccelerateInterpolator();
        case ANTICIPATE_INTERPOLATOR:
            return new AnticipateInterpolator();
        case ANTICIPATE_OVERSHOOT_INTERPOLATOR:
            return new AnticipateOvershootInterpolator();
        case BOUNCE_INTERPOLATOR:
            return new BounceInterpolator();
        case DECELERATE_INTERPOLATOR:
            return new DecelerateInterpolator();
        case FAST_OUT_LINEAR_IN_INTERPOLATOR:
            return new FastOutLinearInInterpolator();
        case FAST_OUT_SLOW_IN_INTERPOLATOR:
            return new FastOutSlowInInterpolator();
        case LINEAR_INTERPOLATOR:
            return new LinearInterpolator();
        case LINEAR_OUT_SLOW_IN_INTERPOLATOR:
            return new LinearOutSlowInInterpolator();
        case OVERSHOOT_INTERPOLATOR:
            return new OvershootInterpolator();
        default:
            return new LinearInterpolator();
    }
}

private static void addAnimation(Collection<Animator> animators, View view, TimeInterpolator interpolator, int duration, int delay) {
    Animator scaleX = ObjectAnimator.ofFloat(view, View.SCALE_X, 0f, 1f);
    scaleX.setInterpolator(interpolator);
    scaleX.setDuration(duration);
    scaleX.setStartDelay(delay);
    animators.add(scaleX);

    Animator scaleY = ObjectAnimator.ofFloat(view, View.SCALE_Y, 0f, 1f);
    scaleY.setInterpolator(interpolator);
    scaleY.setDuration(duration);
    scaleY.setStartDelay(delay);
    animators.add(scaleY);
}

protected void snapToPage(int whichPage, int duration, boolean immediate,
        TimeInterpolator interpolator) {
    whichPage = validateNewPage(whichPage);

    int newX = getScrollForPage(whichPage);
    final int delta = newX - getUnboundedScrollX();
    snapToPage(whichPage, delta, duration, immediate, interpolator);
}

public static MoveData startAnimation(Context context, final View toView, Bundle transitionBundle, Bundle savedInstanceState, final int duration, final TimeInterpolator interpolator) {
    final TransitionData transitionData = new TransitionData(context, transitionBundle);
    if (transitionData.imageFilePath != null) {
        setImageToView(toView, transitionData.imageFilePath);
    }
    final MoveData moveData = new MoveData();
    moveData.toView = toView;
    moveData.duration = duration;
    if (savedInstanceState == null) {

        ViewTreeObserver observer = toView.getViewTreeObserver();
        observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {

            @Override
            public boolean onPreDraw() {
                toView.getViewTreeObserver().removeOnPreDrawListener(this);

                int[] screenLocation = new int[2];
                toView.getLocationOnScreen(screenLocation);
                moveData.leftDelta = transitionData.thumbnailLeft - screenLocation[0];
                moveData.topDelta = transitionData.thumbnailTop - screenLocation[1];

                moveData.widthScale = (float) transitionData.thumbnailWidth / toView.getWidth();
                moveData.heightScale = (float) transitionData.thumbnailHeight / toView.getHeight();

                runEnterAnimation(moveData, interpolator);

                return true;
            }
        });
    }
    return moveData;
}

private static void runEnterAnimation(MoveData moveData, TimeInterpolator interpolator) {
    final View toView = moveData.toView;
    toView.setPivotX(0);
    toView.setPivotY(0);
    toView.setScaleX(moveData.widthScale);
    toView.setScaleY(moveData.heightScale);
    toView.setTranslationX(moveData.leftDelta);
    toView.setTranslationY(moveData.topDelta);

    toView.animate().setDuration(moveData.duration).
            scaleX(1).scaleY(1).
            translationX(0).translationY(0).
            setInterpolator(interpolator);
}

/**
 * @param target
 * @param star     动画起始坐标
 * @param end      动画终止坐标
 * @param duration 持续时间
 * @return 创建一个从左到右的飞入动画
 * 礼物飞入动画
 */
public static ObjectAnimator createFlyFromLtoR(final View target, float star, float end, int duration, TimeInterpolator interpolator) {
    //1.个人信息先飞出来
    ObjectAnimator anim1 = ObjectAnimator.ofFloat(target, "translationX",
            star, end);
    anim1.setInterpolator(interpolator);
    anim1.setDuration(duration);
    return anim1;
}

@Override
public TimeInterpolator getInterpolator() {
    return mAnimator.getInterpolator();
}

@Override
public void setInterpolator(TimeInterpolator timeInterpolator) {
    mAnimator.setInterpolator(timeInterpolator);
}

@Override public void setInterpolator(TimeInterpolator value) {
  mWrappedAnimator.setInterpolator(value);
}

public void setAnimInterpolator(@NonNull TimeInterpolator timeInterpolator) {
    mProgressAnimator.setInterpolator(timeInterpolator);
    mMaxAnimator.setInterpolator(timeInterpolator);
}

public GuillotineBuilder setInterpolator(TimeInterpolator interpolator) {
    this.interpolator = interpolator;
    return this;
}

private WoWoTranslationAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, float fromX, float fromY, float toX, float toY) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack, fromX, fromY, toX, toY);
}

public void setInterpolator(TimeInterpolator interpolator) {
    mInterpolator = interpolator;
}

private WoWoPathAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, WoWoPathView pathView, float fromProcess, float toProcess) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack);
    this.pathView = pathView;
    this.fromProcess = fromProcess;
    this.toProcess = toProcess;
}

private WoWoPosition3DAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, float fromX, float fromY, float fromZ, float toX, float toY, float toZ) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack, fromX, fromY, fromZ, toX, toY, toZ);
}

public TextPageAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, String fromText, String toText, Typewriter typewriter) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack);
    this.fromText = fromText;
    this.toText = toText;
    this.typewriter = typewriter;
}

private WoWoShapeColorAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, Integer fromColor, Integer toColor, Chameleon chameleon) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack, fromColor, toColor, chameleon);
}

@Override
public void onFlingToDelete(final DragObject d, PointF vel) {
    // Don't highlight the icon as it's animating
    d.dragView.setColor(0);

    final DragLayer dragLayer = mLauncher.getDragLayer();
    FlingAnimation fling = new FlingAnimation(d, vel,
            getIconRect(d.dragView.getMeasuredWidth(), d.dragView.getMeasuredHeight(),
                    mDrawable.getIntrinsicWidth(), mDrawable.getIntrinsicHeight()),
                    dragLayer);

    final int duration = fling.getDuration();
    final long startTime = AnimationUtils.currentAnimationTimeMillis();

    // NOTE: Because it takes time for the first frame of animation to actually be
    // called and we expect the animation to be a continuation of the fling, we have
    // to account for the time that has elapsed since the fling finished.  And since
    // we don't have a startDelay, we will always get call to update when we call
    // start() (which we want to ignore).
    final TimeInterpolator tInterpolator = new TimeInterpolator() {
        private int mCount = -1;
        private float mOffset = 0f;

        @Override
        public float getInterpolation(float t) {
            if (mCount < 0) {
                mCount++;
            } else if (mCount == 0) {
                mOffset = Math.min(0.5f, (float) (AnimationUtils.currentAnimationTimeMillis() -
                        startTime) / duration);
                mCount++;
            }
            return Math.min(1f, mOffset + t);
        }
    };

    Runnable onAnimationEndRunnable = new Runnable() {
        @Override
        public void run() {
            mLauncher.exitSpringLoadedDragMode();
            completeDrop(d);
            mLauncher.getDragController().onDeferredEndFling(d);
        }
    };

    dragLayer.animateView(d.dragView, fling, duration, tInterpolator, onAnimationEndRunnable,
            DragLayer.ANIMATION_END_DISAPPEAR, null);
}

private WoWoElevationAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, float fromElevation, float toElevation) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack);
    this.fromElevation = fromElevation;
    this.toElevation = toElevation;
}

private WoWoPositionAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, float fromX, float fromY, float toX, float toY) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack, fromX, fromY, toX, toY);
}

public WoWoTextViewTextAnimation(int page, float startOffset, float endOffset, int ease, TimeInterpolator interpolator, boolean useSameEaseEnumBack, String fromText, String toText, Typewriter typewriter) {
    super(page, startOffset, endOffset, ease, interpolator, useSameEaseEnumBack, fromText, toText, typewriter);
}

public void start() {
    ValueAnimator mAnimator = ValueAnimator.ofInt(360, 0);
    mAnimator.setDuration(10 * 360);
    mAnimator.setRepeatCount(ValueAnimator.INFINITE);
    mAnimator.setInterpolator(new TimeInterpolator() {

        @Override
        public float getInterpolation(float input) {
            return input;
        }
    });
    mAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            Integer value = (Integer) animation.getAnimatedValue();
            startLinePoint = value / 360f;
            endLinePoint = startLinePoint + 0.5f;
            if (startLinePoint > 0.5f) {
                offsetLinePoint = startLinePoint - 0.5f;
                int splitColor = Color.argb((int) (255 * (offsetLinePoint / 0.5f)), 255, 0, 0);
                colorArray =
                        new int[]{splitColor, 0x00FF0000, 0, 0, 0xFFFF0000, splitColor};
                pathArray =
                        new float[]{0f, offsetLinePoint, offsetLinePoint, startLinePoint, startLinePoint, 1f};
            } else {
                colorArray =
                        new int[]{0, 0, 0xFFFF0000, 0x00FF0000, 0, 0};
                pathArray =
                        new float[]{0f, startLinePoint, startLinePoint, endLinePoint, endLinePoint, 1f};
            }

            SweepGradient mShader = new SweepGradient(250, 250, colorArray, pathArray);
            mBitmapPaint.setShader(mShader);
            mBitmapCanvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR);
            mBitmapCanvas.drawPath(mPath, mBitmapPaint);
            postInvalidate();
        }
    });
    mAnimator.start();
}

@Override
public TimeInterpolator getInterpolator() {
    return mAnimator.getInterpolator();
}