Java tutorial
/* * Copyright 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package cn.androidy.androiddevelopmentpatterns.interactivechart; import android.content.Context; import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Point; import android.graphics.PointF; import android.graphics.Rect; import android.graphics.RectF; import android.os.Parcel; import android.os.Parcelable; import android.support.v4.os.ParcelableCompat; import android.support.v4.os.ParcelableCompatCreatorCallbacks; import android.support.v4.view.GestureDetectorCompat; import android.support.v4.view.ViewCompat; import android.support.v4.widget.EdgeEffectCompat; import android.util.AttributeSet; import android.view.GestureDetector; import android.view.MotionEvent; import android.view.ScaleGestureDetector; import android.view.View; import android.widget.OverScroller; import cn.androidy.androiddevelopmentpatterns.R; /** * A view representing a simple yet interactive line chart for the function <code>x^3 - x/4</code>. * <p/> * This view isn't all that useful on its own; rather it serves as an example of how to correctly * implement these types of gestures to perform zooming and scrolling with interesting content * types. * <p/> * The view is interactive in that it can be zoomed and panned using * typical <a href="http://developer.android.com/design/patterns/gestures.html">gestures</a> such * as double-touch, drag, pinch-open, and pinch-close. This is done using the * {@link ScaleGestureDetector}, {@link GestureDetector}, and {@link OverScroller} classes. Note * that the platform-provided view scrolling behavior (e.g. {@link View#scrollBy(int, int)} is NOT * used. * <p/> * The view also demonstrates the correct use of * <a href="http://developer.android.com/design/style/touch-feedback.html">touch feedback</a> to * indicate to users that they've reached the content edges after a pan or fling gesture. This * is done using the {@link EdgeEffectCompat} class. * <p/> * Finally, this class demonstrates the basics of creating a custom view, including support for * custom attributes (see the constructors), a simple implementation for * {@link #onMeasure(int, int)}, an implementation for {@link #onSaveInstanceState()} and a fairly * straightforward {@link Canvas}-based rendering implementation in * {@link #onDraw(Canvas)}. * <p/> * Note that this view doesn't automatically support directional navigation or other accessibility * methods. Activities using this view should generally provide alternate navigation controls. * Activities using this view should also present an alternate, text-based representation of this * view's content for vision-impaired users. */ public class InteractiveLineGraphView extends View { private static final String TAG = "InteractiveLineGraphView"; /** * The number of individual points (samples) in the chart series to draw onscreen. */ private static final int DRAW_STEPS = 30; /** * Initial fling velocity for pan operations, in screen widths (or heights) per second. * * @see #panLeft() * @see #panRight() * @see #panUp() * @see #panDown() */ private static final float PAN_VELOCITY_FACTOR = 2f; /** * The scaling factor for a single zoom 'step'. * * @see #zoomIn() * @see #zoomOut() */ private static final float ZOOM_AMOUNT = 0.25f; // Viewport extremes. See mCurrentViewport for a discussion of the viewport. private static final float AXIS_X_MIN = -1f; private static final float AXIS_X_MAX = 1f; private static final float AXIS_Y_MIN = -1f; private static final float AXIS_Y_MAX = 1f; /** * The current viewport. This rectangle represents the currently visible chart domain * and range. The currently visible chart X values are from this rectangle's left to its right. * The currently visible chart Y values are from this rectangle's top to its bottom. * <p/> * Note that this rectangle's top is actually the smaller Y value, and its bottom is the larger * Y value. Since the chart is drawn onscreen in such a way that chart Y values increase * towards the top of the screen (decreasing pixel Y positions), this rectangle's "top" is drawn * above this rectangle's "bottom" value. * * @see #mContentRect */ private RectF mCurrentViewport = new RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX); /** * The current destination rectangle (in pixel coordinates) into which the chart data should * be drawn. Chart labels are drawn outside this area. * * @see #mCurrentViewport */ private Rect mContentRect = new Rect(); // Current attribute values and Paints. private float mLabelTextSize; private int mLabelSeparation; private int mLabelTextColor; private Paint mLabelTextPaint; private int mMaxLabelWidth; private int mLabelHeight; private float mGridThickness; private int mGridColor; private Paint mGridPaint; private float mAxisThickness; private int mAxisColor; private Paint mAxisPaint; private float mDataThickness; private int mDataColor; private Paint mDataPaint; // State objects and values related to gesture tracking. private ScaleGestureDetector mScaleGestureDetector; private GestureDetectorCompat mGestureDetector; private OverScroller mScroller; private Zoomer mZoomer; private PointF mZoomFocalPoint = new PointF(); private RectF mScrollerStartViewport = new RectF(); // Used only for zooms and flings. // Edge effect / overscroll tracking objects. private EdgeEffectCompat mEdgeEffectTop; private EdgeEffectCompat mEdgeEffectBottom; private EdgeEffectCompat mEdgeEffectLeft; private EdgeEffectCompat mEdgeEffectRight; private boolean mEdgeEffectTopActive; private boolean mEdgeEffectBottomActive; private boolean mEdgeEffectLeftActive; private boolean mEdgeEffectRightActive; // Buffers for storing current X and Y stops. See the computeAxisStops method for more details. private final AxisStops mXStopsBuffer = new AxisStops(); private final AxisStops mYStopsBuffer = new AxisStops(); // Buffers used during drawing. These are defined as fields to avoid allocation during // draw calls. private float[] mAxisXPositionsBuffer = new float[] {}; private float[] mAxisYPositionsBuffer = new float[] {}; private float[] mAxisXLinesBuffer = new float[] {}; private float[] mAxisYLinesBuffer = new float[] {}; private float[] mSeriesLinesBuffer = new float[(DRAW_STEPS + 1) * 4]; private final char[] mLabelBuffer = new char[100]; private Point mSurfaceSizeBuffer = new Point(); /** * The simple math function Y = fun(X) to draw on the chart. * * @param x The X value * @return The Y value */ protected static float fun(float x) { return (float) Math.pow(x, 3) - x / 4; } public InteractiveLineGraphView(Context context) { this(context, null, 0); } public InteractiveLineGraphView(Context context, AttributeSet attrs) { this(context, attrs, 0); } public InteractiveLineGraphView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); TypedArray a = context.getTheme().obtainStyledAttributes(attrs, R.styleable.InteractiveLineGraphView, defStyle, defStyle); try { mLabelTextColor = a.getColor(R.styleable.InteractiveLineGraphView_labelTextColor, mLabelTextColor); mLabelTextSize = a.getDimension(R.styleable.InteractiveLineGraphView_labelTextSize, mLabelTextSize); mLabelSeparation = a.getDimensionPixelSize(R.styleable.InteractiveLineGraphView_labelSeparation, mLabelSeparation); mGridThickness = a.getDimension(R.styleable.InteractiveLineGraphView_gridThickness, mGridThickness); mGridColor = a.getColor(R.styleable.InteractiveLineGraphView_gridColor, mGridColor); mAxisThickness = a.getDimension(R.styleable.InteractiveLineGraphView_axisThickness, mAxisThickness); mAxisColor = a.getColor(R.styleable.InteractiveLineGraphView_axisColor, mAxisColor); mDataThickness = a.getDimension(R.styleable.InteractiveLineGraphView_dataThickness, mDataThickness); mDataColor = a.getColor(R.styleable.InteractiveLineGraphView_dataColor, mDataColor); } finally { a.recycle(); } initPaints(); // Sets up interactions mScaleGestureDetector = new ScaleGestureDetector(context, mScaleGestureListener); mGestureDetector = new GestureDetectorCompat(context, mGestureListener); mScroller = new OverScroller(context); mZoomer = new Zoomer(context); // Sets up edge effects mEdgeEffectLeft = new EdgeEffectCompat(context); mEdgeEffectTop = new EdgeEffectCompat(context); mEdgeEffectRight = new EdgeEffectCompat(context); mEdgeEffectBottom = new EdgeEffectCompat(context); } /** * (Re)initializes {@link Paint} objects based on current attribute values. */ private void initPaints() { mLabelTextPaint = new Paint(); mLabelTextPaint.setAntiAlias(true); mLabelTextPaint.setTextSize(mLabelTextSize); mLabelTextPaint.setColor(mLabelTextColor); mLabelHeight = (int) Math.abs(mLabelTextPaint.getFontMetrics().top); mMaxLabelWidth = (int) mLabelTextPaint.measureText("0000"); mGridPaint = new Paint(); mGridPaint.setStrokeWidth(mGridThickness); mGridPaint.setColor(mGridColor); mGridPaint.setStyle(Paint.Style.STROKE); mAxisPaint = new Paint(); mAxisPaint.setStrokeWidth(mAxisThickness); mAxisPaint.setColor(mAxisColor); mAxisPaint.setStyle(Paint.Style.STROKE); mDataPaint = new Paint(); mDataPaint.setStrokeWidth(mDataThickness); mDataPaint.setColor(mDataColor); mDataPaint.setStyle(Paint.Style.STROKE); mDataPaint.setAntiAlias(true); } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); mContentRect.set(getPaddingLeft() + mMaxLabelWidth + mLabelSeparation, getPaddingTop(), getWidth() - getPaddingRight(), getHeight() - getPaddingBottom() - mLabelHeight - mLabelSeparation); } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int minChartSize = getResources().getDimensionPixelSize(R.dimen.min_chart_size); setMeasuredDimension( Math.max(getSuggestedMinimumWidth(), resolveSize(minChartSize + getPaddingLeft() + mMaxLabelWidth + mLabelSeparation + getPaddingRight(), widthMeasureSpec)), Math.max(getSuggestedMinimumHeight(), resolveSize( minChartSize + getPaddingTop() + mLabelHeight + mLabelSeparation + getPaddingBottom(), heightMeasureSpec))); } //////////////////////////////////////////////////////////////////////////////////////////////// // // Methods and objects related to drawing // //////////////////////////////////////////////////////////////////////////////////////////////// @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); // Draws axes and text labels drawAxes(canvas); // Clips the next few drawing operations to the content area int clipRestoreCount = canvas.save(); canvas.clipRect(mContentRect); drawDataSeriesUnclipped(canvas); drawEdgeEffectsUnclipped(canvas); // Removes clipping rectangle canvas.restoreToCount(clipRestoreCount); // Draws chart container canvas.drawRect(mContentRect, mAxisPaint); } /** * Draws the chart axes and labels onto the canvas. */ private void drawAxes(Canvas canvas) { // Computes axis stops (in terms of numerical value and position on screen) int i; computeAxisStops(mCurrentViewport.left, mCurrentViewport.right, mContentRect.width() / mMaxLabelWidth / 2, mXStopsBuffer); computeAxisStops(mCurrentViewport.top, mCurrentViewport.bottom, mContentRect.height() / mLabelHeight / 2, mYStopsBuffer); // Avoid unnecessary allocations during drawing. Re-use allocated // arrays and only reallocate if the number of stops grows. if (mAxisXPositionsBuffer.length < mXStopsBuffer.numStops) { mAxisXPositionsBuffer = new float[mXStopsBuffer.numStops]; } if (mAxisYPositionsBuffer.length < mYStopsBuffer.numStops) { mAxisYPositionsBuffer = new float[mYStopsBuffer.numStops]; } if (mAxisXLinesBuffer.length < mXStopsBuffer.numStops * 4) { mAxisXLinesBuffer = new float[mXStopsBuffer.numStops * 4]; } if (mAxisYLinesBuffer.length < mYStopsBuffer.numStops * 4) { mAxisYLinesBuffer = new float[mYStopsBuffer.numStops * 4]; } // Compute positions for (i = 0; i < mXStopsBuffer.numStops; i++) { mAxisXPositionsBuffer[i] = getDrawX(mXStopsBuffer.stops[i]); } for (i = 0; i < mYStopsBuffer.numStops; i++) { mAxisYPositionsBuffer[i] = getDrawY(mYStopsBuffer.stops[i]); } // Draws grid lines using drawLines (faster than individual drawLine calls) for (i = 0; i < mXStopsBuffer.numStops; i++) { mAxisXLinesBuffer[i * 4 + 0] = (float) Math.floor(mAxisXPositionsBuffer[i]); mAxisXLinesBuffer[i * 4 + 1] = mContentRect.top; mAxisXLinesBuffer[i * 4 + 2] = (float) Math.floor(mAxisXPositionsBuffer[i]); mAxisXLinesBuffer[i * 4 + 3] = mContentRect.bottom; } canvas.drawLines(mAxisXLinesBuffer, 0, mXStopsBuffer.numStops * 4, mGridPaint); for (i = 0; i < mYStopsBuffer.numStops; i++) { mAxisYLinesBuffer[i * 4 + 0] = mContentRect.left; mAxisYLinesBuffer[i * 4 + 1] = (float) Math.floor(mAxisYPositionsBuffer[i]); mAxisYLinesBuffer[i * 4 + 2] = mContentRect.right; mAxisYLinesBuffer[i * 4 + 3] = (float) Math.floor(mAxisYPositionsBuffer[i]); } canvas.drawLines(mAxisYLinesBuffer, 0, mYStopsBuffer.numStops * 4, mGridPaint); // Draws X labels int labelOffset; int labelLength; mLabelTextPaint.setTextAlign(Paint.Align.CENTER); for (i = 0; i < mXStopsBuffer.numStops; i++) { // Do not use String.format in high-performance code such as onDraw code. labelLength = formatFloat(mLabelBuffer, mXStopsBuffer.stops[i], mXStopsBuffer.decimals); labelOffset = mLabelBuffer.length - labelLength; canvas.drawText(mLabelBuffer, labelOffset, labelLength, mAxisXPositionsBuffer[i], mContentRect.bottom + mLabelHeight + mLabelSeparation, mLabelTextPaint); } // Draws Y labels mLabelTextPaint.setTextAlign(Paint.Align.RIGHT); for (i = 0; i < mYStopsBuffer.numStops; i++) { // Do not use String.format in high-performance code such as onDraw code. labelLength = formatFloat(mLabelBuffer, mYStopsBuffer.stops[i], mYStopsBuffer.decimals); labelOffset = mLabelBuffer.length - labelLength; canvas.drawText(mLabelBuffer, labelOffset, labelLength, mContentRect.left - mLabelSeparation, mAxisYPositionsBuffer[i] + mLabelHeight / 2, mLabelTextPaint); } } /** * Rounds the given number to the given number of significant digits. Based on an answer on * <a href="http://stackoverflow.com/questions/202302">Stack Overflow</a>. */ private static float roundToOneSignificantFigure(double num) { final float d = (float) Math.ceil((float) Math.log10(num < 0 ? -num : num)); final int power = 1 - (int) d; final float magnitude = (float) Math.pow(10, power); final long shifted = Math.round(num * magnitude); return shifted / magnitude; } private static final int POW10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000 }; /** * Formats a float value to the given number of decimals. Returns the length of the string. * The string begins at out.length - [return value]. */ private static int formatFloat(final char[] out, float val, int digits) { boolean negative = false; if (val == 0) { out[out.length - 1] = '0'; return 1; } if (val < 0) { negative = true; val = -val; } if (digits > POW10.length) { digits = POW10.length - 1; } val *= POW10[digits]; long lval = Math.round(val); int index = out.length - 1; int charCount = 0; while (lval != 0 || charCount < (digits + 1)) { int digit = (int) (lval % 10); lval = lval / 10; out[index--] = (char) (digit + '0'); charCount++; if (charCount == digits) { out[index--] = '.'; charCount++; } } if (negative) { out[index--] = '-'; charCount++; } return charCount; } /** * Computes the set of axis labels to show given start and stop boundaries and an ideal number * of stops between these boundaries. * * @param start The minimum extreme (e.g. the left edge) for the axis. * @param stop The maximum extreme (e.g. the right edge) for the axis. * @param steps The ideal number of stops to create. This should be based on available screen * space; the more space there is, the more stops should be shown. * @param outStops The destination {@link AxisStops} object to populate. */ private static void computeAxisStops(float start, float stop, int steps, AxisStops outStops) { double range = stop - start; if (steps == 0 || range <= 0) { outStops.stops = new float[] {}; outStops.numStops = 0; return; } double rawInterval = range / steps; double interval = roundToOneSignificantFigure(rawInterval); double intervalMagnitude = Math.pow(10, (int) Math.log10(interval)); int intervalSigDigit = (int) (interval / intervalMagnitude); if (intervalSigDigit > 5) { // Use one order of magnitude higher, to avoid intervals like 0.9 or 90 interval = Math.floor(10 * intervalMagnitude); } double first = Math.ceil(start / interval) * interval; double last = Math.nextUp(Math.floor(stop / interval) * interval); double f; int i; int n = 0; for (f = first; f <= last; f += interval) { ++n; } outStops.numStops = n; if (outStops.stops.length < n) { // Ensure stops contains at least numStops elements. outStops.stops = new float[n]; } for (f = first, i = 0; i < n; f += interval, ++i) { outStops.stops[i] = (float) f; } if (interval < 1) { outStops.decimals = (int) Math.ceil(-Math.log10(interval)); } else { outStops.decimals = 0; } } /** * Computes the pixel offset for the given X chart value. This may be outside the view bounds. */ private float getDrawX(float x) { return mContentRect.left + mContentRect.width() * (x - mCurrentViewport.left) / mCurrentViewport.width(); } /** * Computes the pixel offset for the given Y chart value. This may be outside the view bounds. */ private float getDrawY(float y) { return mContentRect.bottom - mContentRect.height() * (y - mCurrentViewport.top) / mCurrentViewport.height(); } /** * Draws the currently visible portion of the data series defined by {@link #fun(float)} to the * canvas. This method does not clip its drawing, so users should call {@link Canvas#clipRect * before calling this method. */ private void drawDataSeriesUnclipped(Canvas canvas) { mSeriesLinesBuffer[0] = mContentRect.left; mSeriesLinesBuffer[1] = getDrawY(fun(mCurrentViewport.left)); mSeriesLinesBuffer[2] = mSeriesLinesBuffer[0]; mSeriesLinesBuffer[3] = mSeriesLinesBuffer[1]; float x; for (int i = 1; i <= DRAW_STEPS; i++) { mSeriesLinesBuffer[i * 4 + 0] = mSeriesLinesBuffer[(i - 1) * 4 + 2]; mSeriesLinesBuffer[i * 4 + 1] = mSeriesLinesBuffer[(i - 1) * 4 + 3]; x = (mCurrentViewport.left + (mCurrentViewport.width() / DRAW_STEPS * i)); mSeriesLinesBuffer[i * 4 + 2] = getDrawX(x); mSeriesLinesBuffer[i * 4 + 3] = getDrawY(fun(x)); } canvas.drawLines(mSeriesLinesBuffer, mDataPaint); } /** * Draws the overscroll "glow" at the four edges of the chart region, if necessary. The edges * of the chart region are stored in {@link #mContentRect}. * * @see EdgeEffectCompat */ private void drawEdgeEffectsUnclipped(Canvas canvas) { // The methods below rotate and translate the canvas as needed before drawing the glow, // since EdgeEffectCompat always draws a top-glow at 0,0. boolean needsInvalidate = false; if (!mEdgeEffectTop.isFinished()) { final int restoreCount = canvas.save(); canvas.translate(mContentRect.left, mContentRect.top); mEdgeEffectTop.setSize(mContentRect.width(), mContentRect.height()); if (mEdgeEffectTop.draw(canvas)) { needsInvalidate = true; } canvas.restoreToCount(restoreCount); } if (!mEdgeEffectBottom.isFinished()) { final int restoreCount = canvas.save(); canvas.translate(2 * mContentRect.left - mContentRect.right, mContentRect.bottom); canvas.rotate(180, mContentRect.width(), 0); mEdgeEffectBottom.setSize(mContentRect.width(), mContentRect.height()); if (mEdgeEffectBottom.draw(canvas)) { needsInvalidate = true; } canvas.restoreToCount(restoreCount); } if (!mEdgeEffectLeft.isFinished()) { final int restoreCount = canvas.save(); canvas.translate(mContentRect.left, mContentRect.bottom); canvas.rotate(-90, 0, 0); mEdgeEffectLeft.setSize(mContentRect.height(), mContentRect.width()); if (mEdgeEffectLeft.draw(canvas)) { needsInvalidate = true; } canvas.restoreToCount(restoreCount); } if (!mEdgeEffectRight.isFinished()) { final int restoreCount = canvas.save(); canvas.translate(mContentRect.right, mContentRect.top); canvas.rotate(90, 0, 0); mEdgeEffectRight.setSize(mContentRect.height(), mContentRect.width()); if (mEdgeEffectRight.draw(canvas)) { needsInvalidate = true; } canvas.restoreToCount(restoreCount); } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this); } } //////////////////////////////////////////////////////////////////////////////////////////////// // // Methods and objects related to gesture handling // //////////////////////////////////////////////////////////////////////////////////////////////// /** * Finds the chart point (i.e. within the chart's domain and range) represented by the * given pixel coordinates, if that pixel is within the chart region described by * {@link #mContentRect}. If the point is found, the "dest" argument is set to the point and * this function returns true. Otherwise, this function returns false and "dest" is unchanged. */ private boolean hitTest(float x, float y, PointF dest) { if (!mContentRect.contains((int) x, (int) y)) { return false; } dest.set(mCurrentViewport.left + mCurrentViewport.width() * (x - mContentRect.left) / mContentRect.width(), mCurrentViewport.top + mCurrentViewport.height() * (y - mContentRect.bottom) / -mContentRect.height()); return true; } @Override public boolean onTouchEvent(MotionEvent event) { boolean retVal = mScaleGestureDetector.onTouchEvent(event); if (!retVal) { retVal = mGestureDetector.onTouchEvent(event) || retVal; } return retVal || super.onTouchEvent(event); } /** * The scale listener, used for handling multi-finger scale gestures. */ private final ScaleGestureDetector.OnScaleGestureListener mScaleGestureListener = new ScaleGestureDetector.SimpleOnScaleGestureListener() { /** * This is the active focal point in terms of the viewport. Could be a local * variable but kept here to minimize per-frame allocations. */ private PointF viewportFocus = new PointF(); private float lastSpanX; private float lastSpanY; @Override public boolean onScaleBegin(ScaleGestureDetector scaleGestureDetector) { lastSpanX = ScaleGestureDetectorCompat.getCurrentSpanX(scaleGestureDetector); lastSpanY = ScaleGestureDetectorCompat.getCurrentSpanY(scaleGestureDetector); return true; } @Override public boolean onScale(ScaleGestureDetector scaleGestureDetector) { float spanX = ScaleGestureDetectorCompat.getCurrentSpanX(scaleGestureDetector); float spanY = ScaleGestureDetectorCompat.getCurrentSpanY(scaleGestureDetector); float newWidth = lastSpanX / spanX * mCurrentViewport.width(); float newHeight = lastSpanY / spanY * mCurrentViewport.height(); float focusX = scaleGestureDetector.getFocusX(); float focusY = scaleGestureDetector.getFocusY(); hitTest(focusX, focusY, viewportFocus); mCurrentViewport.set(viewportFocus.x - newWidth * (focusX - mContentRect.left) / mContentRect.width(), viewportFocus.y - newHeight * (mContentRect.bottom - focusY) / mContentRect.height(), 0, 0); mCurrentViewport.right = mCurrentViewport.left + newWidth; mCurrentViewport.bottom = mCurrentViewport.top + newHeight; constrainViewport(); ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this); lastSpanX = spanX; lastSpanY = spanY; return true; } }; /** * Ensures that current viewport is inside the viewport extremes defined by {@link #AXIS_X_MIN}, * {@link #AXIS_X_MAX}, {@link #AXIS_Y_MIN} and {@link #AXIS_Y_MAX}. */ private void constrainViewport() { mCurrentViewport.left = Math.max(AXIS_X_MIN, mCurrentViewport.left); mCurrentViewport.top = Math.max(AXIS_Y_MIN, mCurrentViewport.top); mCurrentViewport.bottom = Math.max(Math.nextUp(mCurrentViewport.top), Math.min(AXIS_Y_MAX, mCurrentViewport.bottom)); mCurrentViewport.right = Math.max(Math.nextUp(mCurrentViewport.left), Math.min(AXIS_X_MAX, mCurrentViewport.right)); } /** * The gesture listener, used for handling simple gestures such as double touches, scrolls, * and flings. */ private final GestureDetector.SimpleOnGestureListener mGestureListener = new GestureDetector.SimpleOnGestureListener() { @Override public boolean onDown(MotionEvent e) { releaseEdgeEffects(); mScrollerStartViewport.set(mCurrentViewport); mScroller.forceFinished(true); ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this); return true; } @Override public boolean onDoubleTap(MotionEvent e) { mZoomer.forceFinished(true); if (hitTest(e.getX(), e.getY(), mZoomFocalPoint)) { mZoomer.startZoom(ZOOM_AMOUNT); } ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this); return true; } @Override public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { // Scrolling uses math based on the viewport (as opposed to math using pixels). /** * Pixel offset is the offset in screen pixels, while viewport offset is the * offset within the current viewport. For additional information on surface sizes * and pixel offsets, see the docs for {@link computeScrollSurfaceSize()}. For * additional information about the viewport, see the comments for * {@link mCurrentViewport}. */ float viewportOffsetX = distanceX * mCurrentViewport.width() / mContentRect.width(); float viewportOffsetY = -distanceY * mCurrentViewport.height() / mContentRect.height(); computeScrollSurfaceSize(mSurfaceSizeBuffer); int scrolledX = (int) (mSurfaceSizeBuffer.x * (mCurrentViewport.left + viewportOffsetX - AXIS_X_MIN) / (AXIS_X_MAX - AXIS_X_MIN)); int scrolledY = (int) (mSurfaceSizeBuffer.y * (AXIS_Y_MAX - mCurrentViewport.bottom - viewportOffsetY) / (AXIS_Y_MAX - AXIS_Y_MIN)); boolean canScrollX = mCurrentViewport.left > AXIS_X_MIN || mCurrentViewport.right < AXIS_X_MAX; boolean canScrollY = mCurrentViewport.top > AXIS_Y_MIN || mCurrentViewport.bottom < AXIS_Y_MAX; setViewportBottomLeft(mCurrentViewport.left + viewportOffsetX, mCurrentViewport.bottom + viewportOffsetY); if (canScrollX && scrolledX < 0) { mEdgeEffectLeft.onPull(scrolledX / (float) mContentRect.width()); mEdgeEffectLeftActive = true; } if (canScrollY && scrolledY < 0) { mEdgeEffectTop.onPull(scrolledY / (float) mContentRect.height()); mEdgeEffectTopActive = true; } if (canScrollX && scrolledX > mSurfaceSizeBuffer.x - mContentRect.width()) { mEdgeEffectRight.onPull( (scrolledX - mSurfaceSizeBuffer.x + mContentRect.width()) / (float) mContentRect.width()); mEdgeEffectRightActive = true; } if (canScrollY && scrolledY > mSurfaceSizeBuffer.y - mContentRect.height()) { mEdgeEffectBottom.onPull( (scrolledY - mSurfaceSizeBuffer.y + mContentRect.height()) / (float) mContentRect.height()); mEdgeEffectBottomActive = true; } return true; } @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { fling((int) -velocityX, (int) -velocityY); return true; } }; private void releaseEdgeEffects() { mEdgeEffectLeftActive = mEdgeEffectTopActive = mEdgeEffectRightActive = mEdgeEffectBottomActive = false; mEdgeEffectLeft.onRelease(); mEdgeEffectTop.onRelease(); mEdgeEffectRight.onRelease(); mEdgeEffectBottom.onRelease(); } private void fling(int velocityX, int velocityY) { releaseEdgeEffects(); // Flings use math in pixels (as opposed to math based on the viewport). computeScrollSurfaceSize(mSurfaceSizeBuffer); mScrollerStartViewport.set(mCurrentViewport); int startX = (int) (mSurfaceSizeBuffer.x * (mScrollerStartViewport.left - AXIS_X_MIN) / (AXIS_X_MAX - AXIS_X_MIN)); int startY = (int) (mSurfaceSizeBuffer.y * (AXIS_Y_MAX - mScrollerStartViewport.bottom) / (AXIS_Y_MAX - AXIS_Y_MIN)); mScroller.forceFinished(true); mScroller.fling(startX, startY, velocityX, velocityY, 0, mSurfaceSizeBuffer.x - mContentRect.width(), 0, mSurfaceSizeBuffer.y - mContentRect.height(), mContentRect.width() / 2, mContentRect.height() / 2); ViewCompat.postInvalidateOnAnimation(this); } /** * Computes the current scrollable surface size, in pixels. For example, if the entire chart * area is visible, this is simply the current size of {@link #mContentRect}. If the chart * is zoomed in 200% in both directions, the returned size will be twice as large horizontally * and vertically. */ private void computeScrollSurfaceSize(Point out) { out.set((int) (mContentRect.width() * (AXIS_X_MAX - AXIS_X_MIN) / mCurrentViewport.width()), (int) (mContentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN) / mCurrentViewport.height())); } @Override public void computeScroll() { super.computeScroll(); boolean needsInvalidate = false; if (mScroller.computeScrollOffset()) { // The scroller isn't finished, meaning a fling or programmatic pan operation is // currently active. computeScrollSurfaceSize(mSurfaceSizeBuffer); int currX = mScroller.getCurrX(); int currY = mScroller.getCurrY(); boolean canScrollX = (mCurrentViewport.left > AXIS_X_MIN || mCurrentViewport.right < AXIS_X_MAX); boolean canScrollY = (mCurrentViewport.top > AXIS_Y_MIN || mCurrentViewport.bottom < AXIS_Y_MAX); if (canScrollX && currX < 0 && mEdgeEffectLeft.isFinished() && !mEdgeEffectLeftActive) { mEdgeEffectLeft.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller)); mEdgeEffectLeftActive = true; needsInvalidate = true; } else if (canScrollX && currX > (mSurfaceSizeBuffer.x - mContentRect.width()) && mEdgeEffectRight.isFinished() && !mEdgeEffectRightActive) { mEdgeEffectRight.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller)); mEdgeEffectRightActive = true; needsInvalidate = true; } if (canScrollY && currY < 0 && mEdgeEffectTop.isFinished() && !mEdgeEffectTopActive) { mEdgeEffectTop.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller)); mEdgeEffectTopActive = true; needsInvalidate = true; } else if (canScrollY && currY > (mSurfaceSizeBuffer.y - mContentRect.height()) && mEdgeEffectBottom.isFinished() && !mEdgeEffectBottomActive) { mEdgeEffectBottom.onAbsorb((int) OverScrollerCompat.getCurrVelocity(mScroller)); mEdgeEffectBottomActive = true; needsInvalidate = true; } float currXRange = AXIS_X_MIN + (AXIS_X_MAX - AXIS_X_MIN) * currX / mSurfaceSizeBuffer.x; float currYRange = AXIS_Y_MAX - (AXIS_Y_MAX - AXIS_Y_MIN) * currY / mSurfaceSizeBuffer.y; setViewportBottomLeft(currXRange, currYRange); } if (mZoomer.computeZoom()) { // Performs the zoom since a zoom is in progress (either programmatically or via // double-touch). float newWidth = (1f - mZoomer.getCurrZoom()) * mScrollerStartViewport.width(); float newHeight = (1f - mZoomer.getCurrZoom()) * mScrollerStartViewport.height(); float pointWithinViewportX = (mZoomFocalPoint.x - mScrollerStartViewport.left) / mScrollerStartViewport.width(); float pointWithinViewportY = (mZoomFocalPoint.y - mScrollerStartViewport.top) / mScrollerStartViewport.height(); mCurrentViewport.set(mZoomFocalPoint.x - newWidth * pointWithinViewportX, mZoomFocalPoint.y - newHeight * pointWithinViewportY, mZoomFocalPoint.x + newWidth * (1 - pointWithinViewportX), mZoomFocalPoint.y + newHeight * (1 - pointWithinViewportY)); constrainViewport(); needsInvalidate = true; } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this); } } /** * Sets the current viewport (defined by {@link #mCurrentViewport}) to the given * X and Y positions. Note that the Y value represents the topmost pixel position, and thus * the bottom of the {@link #mCurrentViewport} rectangle. For more details on why top and * bottom are flipped, see {@link #mCurrentViewport}. */ private void setViewportBottomLeft(float x, float y) { /** * Constrains within the scroll range. The scroll range is simply the viewport extremes * (AXIS_X_MAX, etc.) minus the viewport size. For example, if the extrema were 0 and 10, * and the viewport size was 2, the scroll range would be 0 to 8. */ float curWidth = mCurrentViewport.width(); float curHeight = mCurrentViewport.height(); x = Math.max(AXIS_X_MIN, Math.min(x, AXIS_X_MAX - curWidth)); y = Math.max(AXIS_Y_MIN + curHeight, Math.min(y, AXIS_Y_MAX)); mCurrentViewport.set(x, y - curHeight, x + curWidth, y); ViewCompat.postInvalidateOnAnimation(this); } //////////////////////////////////////////////////////////////////////////////////////////////// // // Methods for programmatically changing the viewport // //////////////////////////////////////////////////////////////////////////////////////////////// /** * Returns the current viewport (visible extremes for the chart domain and range.) */ public RectF getCurrentViewport() { return new RectF(mCurrentViewport); } /** * Sets the chart's current viewport. * * @see #getCurrentViewport() */ public void setCurrentViewport(RectF viewport) { mCurrentViewport = viewport; constrainViewport(); ViewCompat.postInvalidateOnAnimation(this); } /** * Smoothly zooms the chart in one step. */ public void zoomIn() { mScrollerStartViewport.set(mCurrentViewport); mZoomer.forceFinished(true); mZoomer.startZoom(ZOOM_AMOUNT); mZoomFocalPoint.set((mCurrentViewport.right + mCurrentViewport.left) / 2, (mCurrentViewport.bottom + mCurrentViewport.top) / 2); ViewCompat.postInvalidateOnAnimation(this); } /** * Smoothly zooms the chart out one step. */ public void zoomOut() { mScrollerStartViewport.set(mCurrentViewport); mZoomer.forceFinished(true); mZoomer.startZoom(-ZOOM_AMOUNT); mZoomFocalPoint.set((mCurrentViewport.right + mCurrentViewport.left) / 2, (mCurrentViewport.bottom + mCurrentViewport.top) / 2); ViewCompat.postInvalidateOnAnimation(this); } /** * Smoothly pans the chart left one step. */ public void panLeft() { fling((int) (-PAN_VELOCITY_FACTOR * getWidth()), 0); } /** * Smoothly pans the chart right one step. */ public void panRight() { fling((int) (PAN_VELOCITY_FACTOR * getWidth()), 0); } /** * Smoothly pans the chart up one step. */ public void panUp() { fling(0, (int) (-PAN_VELOCITY_FACTOR * getHeight())); } /** * Smoothly pans the chart down one step. */ public void panDown() { fling(0, (int) (PAN_VELOCITY_FACTOR * getHeight())); } //////////////////////////////////////////////////////////////////////////////////////////////// // // Methods related to custom attributes // //////////////////////////////////////////////////////////////////////////////////////////////// public float getLabelTextSize() { return mLabelTextSize; } public void setLabelTextSize(float labelTextSize) { mLabelTextSize = labelTextSize; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public int getLabelTextColor() { return mLabelTextColor; } public void setLabelTextColor(int labelTextColor) { mLabelTextColor = labelTextColor; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public float getGridThickness() { return mGridThickness; } public void setGridThickness(float gridThickness) { mGridThickness = gridThickness; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public int getGridColor() { return mGridColor; } public void setGridColor(int gridColor) { mGridColor = gridColor; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public float getAxisThickness() { return mAxisThickness; } public void setAxisThickness(float axisThickness) { mAxisThickness = axisThickness; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public int getAxisColor() { return mAxisColor; } public void setAxisColor(int axisColor) { mAxisColor = axisColor; initPaints(); ViewCompat.postInvalidateOnAnimation(this); } public float getDataThickness() { return mDataThickness; } public void setDataThickness(float dataThickness) { mDataThickness = dataThickness; } public int getDataColor() { return mDataColor; } public void setDataColor(int dataColor) { mDataColor = dataColor; } //////////////////////////////////////////////////////////////////////////////////////////////// // // Methods and classes related to view state persistence. // //////////////////////////////////////////////////////////////////////////////////////////////// @Override public Parcelable onSaveInstanceState() { Parcelable superState = super.onSaveInstanceState(); SavedState ss = new SavedState(superState); ss.viewport = mCurrentViewport; return ss; } @Override public void onRestoreInstanceState(Parcelable state) { if (!(state instanceof SavedState)) { super.onRestoreInstanceState(state); return; } SavedState ss = (SavedState) state; super.onRestoreInstanceState(ss.getSuperState()); mCurrentViewport = ss.viewport; } /** * Persistent state that is saved by InteractiveLineGraphView. */ public static class SavedState extends BaseSavedState { private RectF viewport; public SavedState(Parcelable superState) { super(superState); } @Override public void writeToParcel(Parcel out, int flags) { super.writeToParcel(out, flags); out.writeFloat(viewport.left); out.writeFloat(viewport.top); out.writeFloat(viewport.right); out.writeFloat(viewport.bottom); } @Override public String toString() { return "InteractiveLineGraphView.SavedState{" + Integer.toHexString(System.identityHashCode(this)) + " viewport=" + viewport.toString() + "}"; } public static final Creator<SavedState> CREATOR = ParcelableCompat .newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() { @Override public SavedState createFromParcel(Parcel in, ClassLoader loader) { return new SavedState(in); } @Override public SavedState[] newArray(int size) { return new SavedState[size]; } }); SavedState(Parcel in) { super(in); viewport = new RectF(in.readFloat(), in.readFloat(), in.readFloat(), in.readFloat()); } } /** * A simple class representing axis label values. * * @see #computeAxisStops */ private static class AxisStops { float[] stops = new float[] {}; int numStops; int decimals; } }