Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 990dfc6f authored by Adam Powell's avatar Adam Powell
Browse files

Sync fling physics between Scroller/OverScroller 

Bug 6793537

Have the default fling physics for Scroller follow the newer patterns
from OverScroller.

Make some constants determined by DisplayMetrics density in
OverScroller per-instance rather than static.

Change-Id: I5308e4bb8eca63e95cf3f1eee1ba4fa5391023b0
parent 2c02933b

core/java/android/widget/OverScroller.java

+12 −17
Original line number Diff line number Diff line
@@ -72,10 +72,8 @@ public class OverScroller { 
    public OverScroller(Context context, Interpolator interpolator, boolean flywheel) {

        mInterpolator = interpolator;

        mFlywheel = flywheel;

        mScrollerX = new SplineOverScroller();

        mScrollerY = new SplineOverScroller();



        SplineOverScroller.initFromContext(context);

        mScrollerX = new SplineOverScroller(context);

        mScrollerY = new SplineOverScroller(context);

    }



    /**
@@ -585,8 +583,8 @@ public class OverScroller { 
        // Constant gravity value, used in the deceleration phase.

        private static final float GRAVITY = 2000.0f;



        // A device specific coefficient adjusted to physical values.

        private static float PHYSICAL_COEF;

        // A context-specific coefficient adjusted to physical values.

        private float mPhysicalCoeff;



        private static float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));

        private static final float INFLEXION = 0.35f; // Tension lines cross at (INFLEXION, 1)
@@ -636,20 +634,17 @@ public class OverScroller { 
            SPLINE_POSITION[NB_SAMPLES] = SPLINE_TIME[NB_SAMPLES] = 1.0f;

        }



        static void initFromContext(Context context) {

            final float ppi = context.getResources().getDisplayMetrics().density * 160.0f;

            PHYSICAL_COEF = SensorManager.GRAVITY_EARTH // g (m/s^2)

                    * 39.37f // inch/meter

                    * ppi

                    * 0.84f; // look and feel tuning

        }



        void setFriction(float friction) {

            mFlingFriction = friction;

        }



        SplineOverScroller() {

        SplineOverScroller(Context context) {

            mFinished = true;

            final float ppi = context.getResources().getDisplayMetrics().density * 160.0f;

            mPhysicalCoeff = SensorManager.GRAVITY_EARTH // g (m/s^2)

                    * 39.37f // inch/meter

                    * ppi

                    * 0.84f; // look and feel tuning

        }



        void updateScroll(float q) {
@@ -785,13 +780,13 @@ public class OverScroller { 
        }



        private double getSplineDeceleration(int velocity) {

            return Math.log(INFLEXION * Math.abs(velocity) / (mFlingFriction * PHYSICAL_COEF));

            return Math.log(INFLEXION * Math.abs(velocity) / (mFlingFriction * mPhysicalCoeff));

        }



        private double getSplineFlingDistance(int velocity) {

            final double l = getSplineDeceleration(velocity);

            final double decelMinusOne = DECELERATION_RATE - 1.0;

            return mFlingFriction * PHYSICAL_COEF * Math.exp(DECELERATION_RATE / decelMinusOne * l);

            return mFlingFriction * mPhysicalCoeff * Math.exp(DECELERATION_RATE / decelMinusOne * l);

        }



        /* Returns the duration, expressed in milliseconds */

core/java/android/widget/Scroller.java

+76 −25
Original line number Diff line number Diff line
@@ -57,45 +57,70 @@ public class Scroller { 
    private boolean mFlywheel;



    private float mVelocity;

    private float mCurrVelocity;

    private int mDistance;



    private float mFlingFriction = ViewConfiguration.getScrollFriction();



    private static final int DEFAULT_DURATION = 250;

    private static final int SCROLL_MODE = 0;

    private static final int FLING_MODE = 1;



    private static float DECELERATION_RATE = (float) (Math.log(0.75) / Math.log(0.9));

    private static float ALPHA = 800; // pixels / seconds

    private static float START_TENSION = 0.4f; // Tension at start: (0.4 * total T, 1.0 * Distance)

    private static float END_TENSION = 1.0f - START_TENSION;

    private static float DECELERATION_RATE = (float) (Math.log(0.78) / Math.log(0.9));

    private static final float INFLEXION = 0.35f; // Tension lines cross at (INFLEXION, 1)

    private static final float START_TENSION = 0.5f;

    private static final float END_TENSION = 1.0f;

    private static final float P1 = START_TENSION * INFLEXION;

    private static final float P2 = 1.0f - END_TENSION * (1.0f - INFLEXION);



    private static final int NB_SAMPLES = 100;

    private static final float[] SPLINE = new float[NB_SAMPLES + 1];

    private static final float[] SPLINE_POSITION = new float[NB_SAMPLES + 1];

    private static final float[] SPLINE_TIME = new float[NB_SAMPLES + 1];



    private float mDeceleration;

    private final float mPpi;



    // A context-specific coefficient adjusted to physical values.

    private float mPhysicalCoeff;



    static {

        float x_min = 0.0f;

        for (int i = 0; i <= NB_SAMPLES; i++) {

            final float t = (float) i / NB_SAMPLES;

        float y_min = 0.0f;

        for (int i = 0; i < NB_SAMPLES; i++) {

            final float alpha = (float) i / NB_SAMPLES;



            float x_max = 1.0f;

            float x, tx, coef;

            while (true) {

                x = x_min + (x_max - x_min) / 2.0f;

                coef = 3.0f * x * (1.0f - x);

                tx = coef * ((1.0f - x) * START_TENSION + x * END_TENSION) + x * x * x;

                if (Math.abs(tx - t) < 1E-5) break;

                if (tx > t) x_max = x;

                tx = coef * ((1.0f - x) * P1 + x * P2) + x * x * x;

                if (Math.abs(tx - alpha) < 1E-5) break;

                if (tx > alpha) x_max = x;

                else x_min = x;

            }

            final float d = coef + x * x * x;

            SPLINE[i] = d;

            SPLINE_POSITION[i] = coef * ((1.0f - x) * START_TENSION + x) + x * x * x;



            float y_max = 1.0f;

            float y, dy;

            while (true) {

                y = y_min + (y_max - y_min) / 2.0f;

                coef = 3.0f * y * (1.0f - y);

                dy = coef * ((1.0f - y) * START_TENSION + y) + y * y * y;

                if (Math.abs(dy - alpha) < 1E-5) break;

                if (dy > alpha) y_max = y;

                else y_min = y;

            }

            SPLINE_TIME[i] = coef * ((1.0f - y) * P1 + y * P2) + y * y * y;

        }

        SPLINE[NB_SAMPLES] = 1.0f;

        SPLINE_POSITION[NB_SAMPLES] = SPLINE_TIME[NB_SAMPLES] = 1.0f;



        // This controls the viscous fluid effect (how much of it)

        sViscousFluidScale = 8.0f;

        // must be set to 1.0 (used in viscousFluid())

        sViscousFluidNormalize = 1.0f;

        sViscousFluidNormalize = 1.0f / viscousFluid(1.0f);



    }



    private static float sViscousFluidScale;
@@ -129,6 +154,8 @@ public class Scroller { 
        mPpi = context.getResources().getDisplayMetrics().density * 160.0f;

        mDeceleration = computeDeceleration(ViewConfiguration.getScrollFriction());

        mFlywheel = flywheel;



        mPhysicalCoeff = computeDeceleration(0.84f); // look and feel tuning

    }



    /**
@@ -140,6 +167,7 @@ public class Scroller { 
     */

    public final void setFriction(float friction) {

        mDeceleration = computeDeceleration(friction);

        mFlingFriction = friction;

    }

    

    private float computeDeceleration(float friction) {
@@ -202,7 +230,8 @@ public class Scroller { 
     * negative.

     */

    public float getCurrVelocity() {

        return mVelocity - mDeceleration * timePassed() / 2000.0f;

        return mMode == FLING_MODE ?

                mCurrVelocity : mVelocity - mDeceleration * timePassed() / 2000.0f;

    }



    /**
@@ -269,11 +298,18 @@ public class Scroller { 
            case FLING_MODE:

                final float t = (float) timePassed / mDuration;

                final int index = (int) (NB_SAMPLES * t);

                float distanceCoef = 1.f;

                float velocityCoef = 0.f;

                if (index < NB_SAMPLES) {

                    final float t_inf = (float) index / NB_SAMPLES;

                    final float t_sup = (float) (index + 1) / NB_SAMPLES;

                final float d_inf = SPLINE[index];

                final float d_sup = SPLINE[index + 1];

                final float distanceCoef = d_inf + (t - t_inf) / (t_sup - t_inf) * (d_sup - d_inf);

                    final float d_inf = SPLINE_POSITION[index];

                    final float d_sup = SPLINE_POSITION[index + 1];

                    velocityCoef = (d_sup - d_inf) / (t_sup - t_inf);

                    distanceCoef = d_inf + (t - t_inf) * velocityCoef;

                }



                mCurrVelocity = velocityCoef * mDistance / mDuration * 1000.0f;

                

                mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));

                // Pin to mMinX <= mCurrX <= mMaxX
@@ -392,8 +428,7 @@ public class Scroller { 
        float velocity = FloatMath.sqrt(velocityX * velocityX + velocityY * velocityY);

     

        mVelocity = velocity;

        final double l = Math.log(START_TENSION * velocity / ALPHA);

        mDuration = (int) (1000.0 * Math.exp(l / (DECELERATION_RATE - 1.0)));

        mDuration = getSplineFlingDuration(velocity);

        mStartTime = AnimationUtils.currentAnimationTimeMillis();

        mStartX = startX;

        mStartY = startY;
@@ -401,25 +436,41 @@ public class Scroller { 
        float coeffX = velocity == 0 ? 1.0f : velocityX / velocity;

        float coeffY = velocity == 0 ? 1.0f : velocityY / velocity;



        int totalDistance =

                (int) (ALPHA * Math.exp(DECELERATION_RATE / (DECELERATION_RATE - 1.0) * l));

        double totalDistance = getSplineFlingDistance(velocity);

        mDistance = (int) (totalDistance * Math.signum(velocity));

        

        mMinX = minX;

        mMaxX = maxX;

        mMinY = minY;

        mMaxY = maxY;



        mFinalX = startX + Math.round(totalDistance * coeffX);

        mFinalX = startX + (int) Math.round(totalDistance * coeffX);

        // Pin to mMinX <= mFinalX <= mMaxX

        mFinalX = Math.min(mFinalX, mMaxX);

        mFinalX = Math.max(mFinalX, mMinX);

        

        mFinalY = startY + Math.round(totalDistance * coeffY);

        mFinalY = startY + (int) Math.round(totalDistance * coeffY);

        // Pin to mMinY <= mFinalY <= mMaxY

        mFinalY = Math.min(mFinalY, mMaxY);

        mFinalY = Math.max(mFinalY, mMinY);

    }

    

    private double getSplineDeceleration(float velocity) {

        return Math.log(INFLEXION * Math.abs(velocity) / (mFlingFriction * mPhysicalCoeff));

    }



    private int getSplineFlingDuration(float velocity) {

        final double l = getSplineDeceleration(velocity);

        final double decelMinusOne = DECELERATION_RATE - 1.0;

        return (int) (1000.0 * Math.exp(l / decelMinusOne));

    }



    private double getSplineFlingDistance(float velocity) {

        final double l = getSplineDeceleration(velocity);

        final double decelMinusOne = DECELERATION_RATE - 1.0;

        return mFlingFriction * mPhysicalCoeff * Math.exp(DECELERATION_RATE / decelMinusOne * l);

    }



    static float viscousFluid(float x)

    {

        x *= sViscousFluidScale;