1 package com.android.deskclock; 2 3 import android.content.Context; 4 import android.content.SharedPreferences; 5 import android.content.res.Resources; 6 import android.graphics.Canvas; 7 import android.graphics.Paint; 8 import android.graphics.RectF; 9 import android.util.AttributeSet; 10 import android.view.View; 11 12 import com.android.deskclock.stopwatch.Stopwatches; 13 14 /** 15 * Class to draw a circle for timers and stopwatches. 16 * These two usages require two different animation modes: 17 * Timer counts down. In this mode the animation is counter-clockwise and stops at 0. 18 * Stopwatch counts up. In this mode the animation is clockwise and will run until stopped. 19 */ 20 public class CircleTimerView extends View { 21 22 23 private int mRedColor; 24 private int mWhiteColor; 25 private long mIntervalTime = 0; 26 private long mIntervalStartTime = -1; 27 private long mMarkerTime = -1; 28 private long mCurrentIntervalTime = 0; 29 private long mAccumulatedTime = 0; 30 private boolean mPaused = false; 31 private boolean mAnimate = false; 32 private static float mStrokeSize = 4; 33 private static float mDotRadius = 6; 34 private static float mMarkerStrokeSize = 2; 35 private final Paint mPaint = new Paint(); 36 private final Paint mFill = new Paint(); 37 private final RectF mArcRect = new RectF(); 38 private float mRadiusOffset; // amount to remove from radius to account for markers on circle 39 private float mScreenDensity; 40 41 // Stopwatch mode is the default. 42 private boolean mTimerMode = false; 43 44 @SuppressWarnings("unused") 45 public CircleTimerView(Context context) { 46 this(context, null); 47 } 48 49 public CircleTimerView(Context context, AttributeSet attrs) { 50 super(context, attrs); 51 init(context); 52 } 53 54 public void setIntervalTime(long t) { 55 mIntervalTime = t; 56 postInvalidate(); 57 } 58 59 public void setMarkerTime(long t) { 60 mMarkerTime = t; 61 postInvalidate(); 62 } 63 64 public void reset() { 65 mIntervalStartTime = -1; 66 mMarkerTime = -1; 67 postInvalidate(); 68 } 69 public void startIntervalAnimation() { 70 mIntervalStartTime = Utils.getTimeNow(); 71 mAnimate = true; 72 invalidate(); 73 mPaused = false; 74 } 75 public void stopIntervalAnimation() { 76 mAnimate = false; 77 mIntervalStartTime = -1; 78 mAccumulatedTime = 0; 79 } 80 81 public boolean isAnimating() { 82 return (mIntervalStartTime != -1); 83 } 84 85 public void pauseIntervalAnimation() { 86 mAnimate = false; 87 mAccumulatedTime += Utils.getTimeNow() - mIntervalStartTime; 88 mPaused = true; 89 } 90 91 public void abortIntervalAnimation() { 92 mAnimate = false; 93 } 94 95 public void setPassedTime(long time, boolean drawRed) { 96 // The onDraw() method checks if mIntervalStartTime has been set before drawing any red. 97 // Without drawRed, mIntervalStartTime should not be set here at all, and would remain at -1 98 // when the state is reconfigured after exiting and re-entering the application. 99 // If the timer is currently running, this drawRed will not be set, and will have no effect 100 // because mIntervalStartTime will be set when the thread next runs. 101 // When the timer is not running, mIntervalStartTime will not be set upon loading the state, 102 // and no red will be drawn, so drawRed is used to force onDraw() to draw the red portion, 103 // despite the timer not running. 104 mCurrentIntervalTime = mAccumulatedTime = time; 105 if (drawRed) { 106 mIntervalStartTime = Utils.getTimeNow(); 107 } 108 postInvalidate(); 109 } 110 111 112 113 private void init(Context c) { 114 115 Resources resources = c.getResources(); 116 mStrokeSize = resources.getDimension(R.dimen.circletimer_circle_size); 117 float dotDiameter = resources.getDimension(R.dimen.circletimer_dot_size); 118 mMarkerStrokeSize = resources.getDimension(R.dimen.circletimer_marker_size); 119 mRadiusOffset = Utils.calculateRadiusOffset( 120 mStrokeSize, dotDiameter, mMarkerStrokeSize); 121 mPaint.setAntiAlias(true); 122 mPaint.setStyle(Paint.Style.STROKE); 123 mWhiteColor = resources.getColor(R.color.clock_white); 124 mRedColor = resources.getColor(R.color.clock_red); 125 mScreenDensity = resources.getDisplayMetrics().density; 126 mFill.setAntiAlias(true); 127 mFill.setStyle(Paint.Style.FILL); 128 mFill.setColor(mRedColor); 129 mDotRadius = dotDiameter / 2f; 130 } 131 132 public void setTimerMode(boolean mode) { 133 mTimerMode = mode; 134 } 135 136 @Override 137 public void onDraw(Canvas canvas) { 138 int xCenter = getWidth() / 2 + 1; 139 int yCenter = getHeight() / 2; 140 141 mPaint.setStrokeWidth(mStrokeSize); 142 float radius = Math.min(xCenter, yCenter) - mRadiusOffset; 143 144 if (mIntervalStartTime == -1) { 145 // just draw a complete white circle, no red arc needed 146 mPaint.setColor(mWhiteColor); 147 canvas.drawCircle (xCenter, yCenter, radius, mPaint); 148 if (mTimerMode) { 149 drawRedDot(canvas, 0f, xCenter, yCenter, radius); 150 } 151 } else { 152 if (mAnimate) { 153 mCurrentIntervalTime = Utils.getTimeNow() - mIntervalStartTime + mAccumulatedTime; 154 } 155 //draw a combination of red and white arcs to create a circle 156 mArcRect.top = yCenter - radius; 157 mArcRect.bottom = yCenter + radius; 158 mArcRect.left = xCenter - radius; 159 mArcRect.right = xCenter + radius; 160 float redPercent = (float)mCurrentIntervalTime / (float)mIntervalTime; 161 // prevent timer from doing more than one full circle 162 redPercent = (redPercent > 1 && mTimerMode) ? 1 : redPercent; 163 164 float whitePercent = 1 - (redPercent > 1 ? 1 : redPercent); 165 // draw red arc here 166 mPaint.setColor(mRedColor); 167 if (mTimerMode){ 168 canvas.drawArc (mArcRect, 270, - redPercent * 360 , false, mPaint); 169 } else { 170 canvas.drawArc (mArcRect, 270, + redPercent * 360 , false, mPaint); 171 } 172 173 // draw white arc here 174 mPaint.setStrokeWidth(mStrokeSize); 175 mPaint.setColor(mWhiteColor); 176 if (mTimerMode) { 177 canvas.drawArc(mArcRect, 270, + whitePercent * 360, false, mPaint); 178 } else { 179 canvas.drawArc(mArcRect, 270 + (1 - whitePercent) * 360, 180 whitePercent * 360, false, mPaint); 181 } 182 183 if (mMarkerTime != -1 && radius > 0 && mIntervalTime != 0) { 184 mPaint.setStrokeWidth(mMarkerStrokeSize); 185 float angle = (float)(mMarkerTime % mIntervalTime) / (float)mIntervalTime * 360; 186 // draw 2dips thick marker 187 // the formula to draw the marker 1 unit thick is: 188 // 180 / (radius * Math.PI) 189 // after that we have to scale it by the screen density 190 canvas.drawArc (mArcRect, 270 + angle, mScreenDensity * 191 (float) (360 / (radius * Math.PI)) , false, mPaint); 192 } 193 drawRedDot(canvas, redPercent, xCenter, yCenter, radius); 194 } 195 if (mAnimate) { 196 invalidate(); 197 } 198 } 199 200 protected void drawRedDot( 201 Canvas canvas, float degrees, int xCenter, int yCenter, float radius) { 202 mPaint.setColor(mRedColor); 203 float dotPercent; 204 if (mTimerMode) { 205 dotPercent = 270 - degrees * 360; 206 } else { 207 dotPercent = 270 + degrees * 360; 208 } 209 210 final double dotRadians = Math.toRadians(dotPercent); 211 canvas.drawCircle(xCenter + (float) (radius * Math.cos(dotRadians)), 212 yCenter + (float) (radius * Math.sin(dotRadians)), mDotRadius, mFill); 213 } 214 215 public static final String PREF_CTV_PAUSED = "_ctv_paused"; 216 public static final String PREF_CTV_INTERVAL = "_ctv_interval"; 217 public static final String PREF_CTV_INTERVAL_START = "_ctv_interval_start"; 218 public static final String PREF_CTV_CURRENT_INTERVAL = "_ctv_current_interval"; 219 public static final String PREF_CTV_ACCUM_TIME = "_ctv_accum_time"; 220 public static final String PREF_CTV_TIMER_MODE = "_ctv_timer_mode"; 221 public static final String PREF_CTV_MARKER_TIME = "_ctv_marker_time"; 222 223 // Since this view is used in multiple places, use the key to save different instances 224 public void writeToSharedPref(SharedPreferences prefs, String key) { 225 SharedPreferences.Editor editor = prefs.edit(); 226 editor.putBoolean (key + PREF_CTV_PAUSED, mPaused); 227 editor.putLong (key + PREF_CTV_INTERVAL, mIntervalTime); 228 editor.putLong (key + PREF_CTV_INTERVAL_START, mIntervalStartTime); 229 editor.putLong (key + PREF_CTV_CURRENT_INTERVAL, mCurrentIntervalTime); 230 editor.putLong (key + PREF_CTV_ACCUM_TIME, mAccumulatedTime); 231 editor.putLong (key + PREF_CTV_MARKER_TIME, mMarkerTime); 232 editor.putBoolean (key + PREF_CTV_TIMER_MODE, mTimerMode); 233 editor.apply(); 234 } 235 236 public void readFromSharedPref(SharedPreferences prefs, String key) { 237 mPaused = prefs.getBoolean(key + PREF_CTV_PAUSED, false); 238 mIntervalTime = prefs.getLong(key + PREF_CTV_INTERVAL, 0); 239 mIntervalStartTime = prefs.getLong(key + PREF_CTV_INTERVAL_START, -1); 240 mCurrentIntervalTime = prefs.getLong(key + PREF_CTV_CURRENT_INTERVAL, 0); 241 mAccumulatedTime = prefs.getLong(key + PREF_CTV_ACCUM_TIME, 0); 242 mMarkerTime = prefs.getLong(key + PREF_CTV_MARKER_TIME, -1); 243 mTimerMode = prefs.getBoolean(key + PREF_CTV_TIMER_MODE, false); 244 mAnimate = (mIntervalStartTime != -1 && !mPaused); 245 } 246 247 public void clearSharedPref(SharedPreferences prefs, String key) { 248 SharedPreferences.Editor editor = prefs.edit(); 249 editor.remove (Stopwatches.PREF_START_TIME); 250 editor.remove (Stopwatches.PREF_ACCUM_TIME); 251 editor.remove (Stopwatches.PREF_STATE); 252 editor.remove (key + PREF_CTV_PAUSED); 253 editor.remove (key + PREF_CTV_INTERVAL); 254 editor.remove (key + PREF_CTV_INTERVAL_START); 255 editor.remove (key + PREF_CTV_CURRENT_INTERVAL); 256 editor.remove (key + PREF_CTV_ACCUM_TIME); 257 editor.remove (key + PREF_CTV_MARKER_TIME); 258 editor.remove (key + PREF_CTV_TIMER_MODE); 259 editor.apply(); 260 } 261 } 262
