FileDocCategorySizeDatePackage
FlingAnimationUtils.javaAPI DocAndroid 5.1 API13294Thu Mar 12 22:22:42 GMT 2015com.android.systemui.statusbar

FlingAnimationUtils

public class FlingAnimationUtils extends Object
Utility class to calculate general fling animation when the finger is released.

Fields Summary
private static final float
LINEAR_OUT_SLOW_IN_X2
private static final float
LINEAR_OUT_FASTER_IN_X2
private static final float
LINEAR_OUT_FASTER_IN_Y2_MIN
private static final float
LINEAR_OUT_FASTER_IN_Y2_MAX
private static final float
MIN_VELOCITY_DP_PER_SECOND
private static final float
HIGH_VELOCITY_DP_PER_SECOND
private static final float
LINEAR_OUT_SLOW_IN_START_GRADIENT
Crazy math. http://en.wikipedia.org/wiki/B%C3%A9zier_curve
private android.view.animation.Interpolator
mLinearOutSlowIn
private android.view.animation.Interpolator
mFastOutSlowIn
private android.view.animation.Interpolator
mFastOutLinearIn
private float
mMinVelocityPxPerSecond
private float
mMaxLengthSeconds
private float
mHighVelocityPxPerSecond
private AnimatorProperties
mAnimatorProperties
Constructors Summary
public FlingAnimationUtils(android.content.Context ctx, float maxLengthSeconds)


         
        mMaxLengthSeconds = maxLengthSeconds;
        mLinearOutSlowIn = new PathInterpolator(0, 0, LINEAR_OUT_SLOW_IN_X2, 1);
        mFastOutSlowIn
                = AnimationUtils.loadInterpolator(ctx, android.R.interpolator.fast_out_slow_in);
        mFastOutLinearIn
                = AnimationUtils.loadInterpolator(ctx, android.R.interpolator.fast_out_linear_in);
        mMinVelocityPxPerSecond
                = MIN_VELOCITY_DP_PER_SECOND * ctx.getResources().getDisplayMetrics().density;
        mHighVelocityPxPerSecond
                = HIGH_VELOCITY_DP_PER_SECOND * ctx.getResources().getDisplayMetrics().density;
Methods Summary
public voidapply(android.animation.Animator animator, float currValue, float endValue, float velocity)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion

        apply(animator, currValue, endValue, velocity, Math.abs(endValue - currValue));
public voidapply(android.view.ViewPropertyAnimator animator, float currValue, float endValue, float velocity)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion

        apply(animator, currValue, endValue, velocity, Math.abs(endValue - currValue));
public voidapply(android.animation.Animator animator, float currValue, float endValue, float velocity, float maxDistance)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion
param
maxDistance the maximum distance for this interaction; the maximum animation length gets multiplied by the ratio between the actual distance and this value

        AnimatorProperties properties = getProperties(currValue, endValue, velocity,
                maxDistance);
        animator.setDuration(properties.duration);
        animator.setInterpolator(properties.interpolator);
public voidapply(android.view.ViewPropertyAnimator animator, float currValue, float endValue, float velocity, float maxDistance)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion
param
maxDistance the maximum distance for this interaction; the maximum animation length gets multiplied by the ratio between the actual distance and this value

        AnimatorProperties properties = getProperties(currValue, endValue, velocity,
                maxDistance);
        animator.setDuration(properties.duration);
        animator.setInterpolator(properties.interpolator);
public voidapplyDismissing(android.animation.Animator animator, float currValue, float endValue, float velocity, float maxDistance)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion for the case when the animation is making something disappear.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion
param
maxDistance the maximum distance for this interaction; the maximum animation length gets multiplied by the ratio between the actual distance and this value

        AnimatorProperties properties = getDismissingProperties(currValue, endValue, velocity,
                maxDistance);
        animator.setDuration(properties.duration);
        animator.setInterpolator(properties.interpolator);
public voidapplyDismissing(android.view.ViewPropertyAnimator animator, float currValue, float endValue, float velocity, float maxDistance)
Applies the interpolator and length to the animator, such that the fling animation is consistent with the finger motion for the case when the animation is making something disappear.

param
animator the animator to apply
param
currValue the current value
param
endValue the end value of the animator
param
velocity the current velocity of the motion
param
maxDistance the maximum distance for this interaction; the maximum animation length gets multiplied by the ratio between the actual distance and this value

        AnimatorProperties properties = getDismissingProperties(currValue, endValue, velocity,
                maxDistance);
        animator.setDuration(properties.duration);
        animator.setInterpolator(properties.interpolator);
private floatcalculateLinearOutFasterInY2(float velocity)
Calculates the y2 control point for a linear-out-faster-in path interpolator depending on the velocity. The faster the velocity, the more "linear" the interpolator gets.

param
velocity the velocity of the gesture.
return
the y2 control point for a cubic bezier path interpolator

        float t = (velocity - mMinVelocityPxPerSecond)
                / (mHighVelocityPxPerSecond - mMinVelocityPxPerSecond);
        t = Math.max(0, Math.min(1, t));
        return (1 - t) * LINEAR_OUT_FASTER_IN_Y2_MIN + t * LINEAR_OUT_FASTER_IN_Y2_MAX;
private com.android.systemui.statusbar.FlingAnimationUtils$AnimatorPropertiesgetDismissingProperties(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, mLinearOutSlowIn);
            mAnimatorProperties.interpolator = superInterpolator;
        } else {

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

return
the minimum velocity a gesture needs to have to be considered a fling

        return mMinVelocityPxPerSecond;
private com.android.systemui.statusbar.FlingAnimationUtils$AnimatorPropertiesgetProperties(float currValue, float endValue, float velocity, float maxDistance)

        float maxLengthSeconds = (float) (mMaxLengthSeconds
                * Math.sqrt(Math.abs(endValue - currValue) / maxDistance));
        float diff = Math.abs(endValue - currValue);
        float velAbs = Math.abs(velocity);
        float durationSeconds = LINEAR_OUT_SLOW_IN_START_GRADIENT * diff / velAbs;
        if (durationSeconds <= maxLengthSeconds) {
            mAnimatorProperties.interpolator = mLinearOutSlowIn;
        } else if (velAbs >= mMinVelocityPxPerSecond) {

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

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