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

Commit c57ceaaa authored by Alex Kulesza's avatar Alex Kulesza
Browse files

Implement general projection curve support for UsageGraph. 

Previously, projections were hard-coded in UsageGraph as lines from the
last known point to the corner of the graph. This change replaces that
with support for arbitrary projection curves. Logic for hiding/showing
the projection is now gone; if the client does not want a projection,
it simply does not supply one.

There are two active clients of this code: the data usage graph and the
battery usage graph. The data graph does not use projections and is
essentially unchanged. The battery graph now implements its linear
extrapolation directly in BatteryInfo.

Bug: 38400320
Test: make SettingsUnitTests SettingsGoogleUnitTests
Test: manual (screenshots in comments)
Change-Id: I754e66f6b18ecb8b936143399f8e9e3368fc1ce4
parent 25f0d195

src/com/android/settings/datausage/ChartDataUsagePreference.java

+1 −1
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ public class ChartDataUsagePreference extends Preference { 


        int top = getTop();

        chart.clearPaths();

        chart.configureGraph(toInt(mEnd - mStart), top, false, false);

        chart.configureGraph(toInt(mEnd - mStart), top);

        calcPoints(chart);

        chart.setBottomLabels(new CharSequence[] {

                Utils.formatDateRange(getContext(), mStart, mStart),

src/com/android/settings/fuelgauge/BatteryInfo.java

+16 −6
Original line number Diff line number Diff line
@@ -55,18 +55,23 @@ public class BatteryInfo { 
    public void bindHistory(final UsageView view, BatteryDataParser... parsers) {

        BatteryDataParser parser = new BatteryDataParser() {

            SparseIntArray points = new SparseIntArray();

            int lastTime = -1;

            byte lastLevel;

            int maxTime;



            @Override

            public void onParsingStarted(long startTime, long endTime) {

                timePeriod = endTime - startTime - remainingTimeUs / 1000;

                this.maxTime = (int) (endTime - startTime);

                timePeriod = maxTime - (remainingTimeUs / 1000);

                view.clearPaths();

                view.configureGraph((int) (endTime - startTime), 100, remainingTimeUs != 0,

                        mCharging);

                view.configureGraph(maxTime, 100);

            }



            @Override

            public void onDataPoint(long time, HistoryItem record) {

                points.put((int) time, record.batteryLevel);

                lastTime = (int) time;

                lastLevel = record.batteryLevel;

                points.put(lastTime, lastLevel);

            }



            @Override
@@ -79,8 +84,13 @@ public class BatteryInfo { 


            @Override

            public void onParsingDone() {

                if (points.size() > 1) {

                    view.addPath(points);

                onDataGap();



                // Add linear projection

                if (lastTime >= 0 && remainingTimeUs != 0) {

                    points.put(lastTime, lastLevel);

                    points.put(maxTime, mCharging ? 100 : 0);

                    view.addProjectedPath(points);

                }

            }

        };

src/com/android/settings/graph/UsageGraph.java

+71 −64
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ import android.util.AttributeSet; 
import android.util.SparseIntArray;

import android.util.TypedValue;

import android.view.View;



import com.android.settingslib.R;



public class UsageGraph extends View {
@@ -52,11 +53,14 @@ public class UsageGraph extends View { 
    private final SparseIntArray mPaths = new SparseIntArray();

    // Paths in local coordinates for drawing.

    private final SparseIntArray mLocalPaths = new SparseIntArray();

    private final int mCornerRadius;



    // Paths for projection in coordinates they are passed in.

    private final SparseIntArray mProjectedPaths = new SparseIntArray();

    // Paths for projection in local coordinates for drawing.

    private final SparseIntArray mLocalProjectedPaths = new SparseIntArray();



    private final int mCornerRadius;

    private int mAccentColor;

    private boolean mShowProjection;

    private boolean mProjectUp;



    private float mMaxX = 100;

    private float mMaxY = 100;
@@ -98,6 +102,9 @@ public class UsageGraph extends View { 


    void clearPaths() {

        mPaths.clear();

        mLocalPaths.clear();

        mProjectedPaths.clear();

        mLocalProjectedPaths.clear();

    }



    void setMax(int maxX, int maxY) {
@@ -115,11 +122,21 @@ public class UsageGraph extends View { 
    }



    public void addPath(SparseIntArray points) {

        for (int i = 0; i < points.size(); i++) {

            mPaths.put(points.keyAt(i), points.valueAt(i));

        addPathAndUpdate(points, mPaths, mLocalPaths);

    }

        mPaths.put(points.keyAt(points.size() - 1) + 1, PATH_DELIM);

        calculateLocalPaths();



    public void addProjectedPath(SparseIntArray points) {

        addPathAndUpdate(points, mProjectedPaths, mLocalProjectedPaths);

    }



    private void addPathAndUpdate(SparseIntArray points, SparseIntArray paths,

            SparseIntArray localPaths) {

        for (int i = 0, size = points.size(); i < size; i++) {

            paths.put(points.keyAt(i), points.valueAt(i));

        }

        // Add a delimiting value immediately after the last point.

        paths.put(points.keyAt(points.size() - 1) + 1, PATH_DELIM);

        calculateLocalPaths(paths, localPaths);

        postInvalidate();

    }
@@ -130,48 +147,45 @@ public class UsageGraph extends View { 
        postInvalidate();

    }



    void setShowProjection(boolean showProjection, boolean projectUp) {

        mShowProjection = showProjection;

        mProjectUp = projectUp;

        postInvalidate();

    }



    @Override

    protected void onSizeChanged(int w, int h, int oldw, int oldh) {

        super.onSizeChanged(w, h, oldw, oldh);

        updateGradient();

        calculateLocalPaths();

        calculateLocalPaths(mPaths, mLocalPaths);

        calculateLocalPaths(mProjectedPaths, mLocalProjectedPaths);

    }



    private void calculateLocalPaths() {

        if (getWidth() == 0) return;

        mLocalPaths.clear();

    private void calculateLocalPaths(SparseIntArray paths, SparseIntArray localPaths) {

        if (getWidth() == 0) {

            return;

        }

        localPaths.clear();

        int pendingXLoc = 0;

        int pendingYLoc = PATH_DELIM;

        for (int i = 0; i < mPaths.size(); i++) {

            int x = mPaths.keyAt(i);

            int y = mPaths.valueAt(i);

        for (int i = 0; i < paths.size(); i++) {

            int x = paths.keyAt(i);

            int y = paths.valueAt(i);

            if (y == PATH_DELIM) {

                if (i == mPaths.size() - 1 && pendingYLoc != PATH_DELIM) {

                if (i == paths.size() - 1 && pendingYLoc != PATH_DELIM) {

                    // Connect to the end of the graph.

                    mLocalPaths.put(pendingXLoc, pendingYLoc);

                    localPaths.put(pendingXLoc, pendingYLoc);

                }

                // Clear out any pending points.

                pendingYLoc = PATH_DELIM;

                mLocalPaths.put(pendingXLoc + 1, PATH_DELIM);

                localPaths.put(pendingXLoc + 1, PATH_DELIM);

            } else {

                final int lx = getX(x);

                final int ly = getY(y);

                pendingXLoc = lx;

                if (mLocalPaths.size() > 0) {

                    int lastX = mLocalPaths.keyAt(mLocalPaths.size() - 1);

                    int lastY = mLocalPaths.valueAt(mLocalPaths.size() - 1);

                if (localPaths.size() > 0) {

                    int lastX = localPaths.keyAt(localPaths.size() - 1);

                    int lastY = localPaths.valueAt(localPaths.size() - 1);

                    if (lastY != PATH_DELIM && !hasDiff(lastX, lx) && !hasDiff(lastY, ly)) {

                        pendingYLoc = ly;

                        continue;

                    }

                }

                mLocalPaths.put(lx, ly);

                localPaths.put(lx, ly);

            }

        }

    }
@@ -189,8 +203,9 @@ public class UsageGraph extends View { 
    }



    private void updateGradient() {

        mFillPaint.setShader(new LinearGradient(0, 0, 0, getHeight(),

                getColor(mAccentColor, .2f), 0, TileMode.CLAMP));

        mFillPaint.setShader(

                new LinearGradient(0, 0, 0, getHeight(), getColor(mAccentColor, .2f), 0,

                        TileMode.CLAMP));

    }



    private int getColor(int color, float alphaScale) {
@@ -207,62 +222,54 @@ public class UsageGraph extends View { 
                mMiddleDividerTint);

        drawDivider(canvas.getHeight() - mDividerSize, canvas, -1);



        if (mLocalPaths.size() == 0) {

        if (mLocalPaths.size() == 0 && mProjectedPaths.size() == 0) {

            return;

        }

        if (mShowProjection) {

            drawProjection(canvas);

        }

        drawFilledPath(canvas);

        drawLinePath(canvas);

        drawLinePath(canvas, mLocalProjectedPaths, mDottedPaint);

        drawFilledPath(canvas, mLocalPaths, mFillPaint);

        drawLinePath(canvas, mLocalPaths, mLinePaint);

    }



    private void drawProjection(Canvas canvas) {

        mPath.reset();

        int x = mLocalPaths.keyAt(mLocalPaths.size() - 2);

        int y = mLocalPaths.valueAt(mLocalPaths.size() - 2);

        mPath.moveTo(x, y);

        mPath.lineTo(canvas.getWidth(), mProjectUp ? 0 : canvas.getHeight());

        canvas.drawPath(mPath, mDottedPaint);

    private void drawLinePath(Canvas canvas, SparseIntArray localPaths, Paint paint) {

        if (localPaths.size() == 0) {

            return;

        }



    private void drawLinePath(Canvas canvas) {

        mPath.reset();

        mPath.moveTo(mLocalPaths.keyAt(0), mLocalPaths.valueAt(0));

        for (int i = 1; i < mLocalPaths.size(); i++) {

            int x = mLocalPaths.keyAt(i);

            int y = mLocalPaths.valueAt(i);

        mPath.moveTo(localPaths.keyAt(0), localPaths.valueAt(0));

        for (int i = 1; i < localPaths.size(); i++) {

            int x = localPaths.keyAt(i);

            int y = localPaths.valueAt(i);

            if (y == PATH_DELIM) {

                if (++i < mLocalPaths.size()) {

                    mPath.moveTo(mLocalPaths.keyAt(i), mLocalPaths.valueAt(i));

                if (++i < localPaths.size()) {

                    mPath.moveTo(localPaths.keyAt(i), localPaths.valueAt(i));

                }

            } else {

                mPath.lineTo(x, y);

            }

        }

        canvas.drawPath(mPath, mLinePaint);

        canvas.drawPath(mPath, paint);

    }



    private void drawFilledPath(Canvas canvas) {

    private void drawFilledPath(Canvas canvas, SparseIntArray localPaths, Paint paint) {

        mPath.reset();

        float lastStartX = mLocalPaths.keyAt(0);

        mPath.moveTo(mLocalPaths.keyAt(0), mLocalPaths.valueAt(0));

        for (int i = 1; i < mLocalPaths.size(); i++) {

            int x = mLocalPaths.keyAt(i);

            int y = mLocalPaths.valueAt(i);

        float lastStartX = localPaths.keyAt(0);

        mPath.moveTo(localPaths.keyAt(0), localPaths.valueAt(0));

        for (int i = 1; i < localPaths.size(); i++) {

            int x = localPaths.keyAt(i);

            int y = localPaths.valueAt(i);

            if (y == PATH_DELIM) {

                mPath.lineTo(mLocalPaths.keyAt(i - 1), getHeight());

                mPath.lineTo(localPaths.keyAt(i - 1), getHeight());

                mPath.lineTo(lastStartX, getHeight());

                mPath.close();

                if (++i < mLocalPaths.size()) {

                    lastStartX = mLocalPaths.keyAt(i);

                    mPath.moveTo(mLocalPaths.keyAt(i), mLocalPaths.valueAt(i));

                if (++i < localPaths.size()) {

                    lastStartX = localPaths.keyAt(i);

                    mPath.moveTo(localPaths.keyAt(i), localPaths.valueAt(i));

                }

            } else {

                mPath.lineTo(x, y);

            }

        }

        canvas.drawPath(mPath, mFillPaint);

        canvas.drawPath(mPath, paint);

    }



    private void drawDivider(int y, Canvas canvas, int tintColor) {

src/com/android/settings/graph/UsageView.java

+5 −2
Original line number Diff line number Diff line
@@ -91,9 +91,12 @@ public class UsageView extends FrameLayout { 
        mUsageGraph.addPath(points);

    }



    public void configureGraph(int maxX, int maxY, boolean showProjection, boolean projectUp) {

    public void addProjectedPath(SparseIntArray points) {

        mUsageGraph.addProjectedPath(points);

    }



    public void configureGraph(int maxX, int maxY) {

        mUsageGraph.setMax(maxX, maxY);

        mUsageGraph.setShowProjection(showProjection, projectUp);

    }



    public void setAccentColor(int color) {