1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.settings.fuelgauge; 18 19 import com.android.settings.R; 20 21 import android.content.Context; 22 import android.content.res.ColorStateList; 23 import android.content.res.TypedArray; 24 import android.graphics.Canvas; 25 import android.graphics.Paint; 26 import android.graphics.Path; 27 import android.graphics.Typeface; 28 import android.os.BatteryStats; 29 import android.os.SystemClock; 30 import android.os.BatteryStats.HistoryItem; 31 import android.telephony.ServiceState; 32 import android.text.TextPaint; 33 import android.util.AttributeSet; 34 import android.util.TypedValue; 35 import android.view.View; 36 37 public class BatteryHistoryChart extends View { 38 static final int CHART_DATA_X_MASK = 0x0000ffff; 39 static final int CHART_DATA_BIN_MASK = 0xffff0000; 40 static final int CHART_DATA_BIN_SHIFT = 16; 41 42 static class ChartData { 43 int[] mColors; 44 Paint[] mPaints; 45 46 int mNumTicks; 47 int[] mTicks; 48 int mLastBin; 49 50 void setColors(int[] colors) { 51 mColors = colors; 52 mPaints = new Paint[colors.length]; 53 for (int i=0; i<colors.length; i++) { 54 mPaints[i] = new Paint(); 55 mPaints[i].setColor(colors[i]); 56 mPaints[i].setStyle(Paint.Style.FILL); 57 } 58 } 59 60 void init(int width) { 61 if (width > 0) { 62 mTicks = new int[width*2]; 63 } else { 64 mTicks = null; 65 } 66 mNumTicks = 0; 67 mLastBin = 0; 68 } 69 70 void addTick(int x, int bin) { 71 if (bin != mLastBin && mNumTicks < mTicks.length) { 72 mTicks[mNumTicks] = x | bin << CHART_DATA_BIN_SHIFT; 73 mNumTicks++; 74 mLastBin = bin; 75 } 76 } 77 78 void finish(int width) { 79 if (mLastBin != 0) { 80 addTick(width, 0); 81 } 82 } 83 84 void draw(Canvas canvas, int top, int height) { 85 int lastBin=0, lastX=0; 86 int bottom = top + height; 87 for (int i=0; i<mNumTicks; i++) { 88 int tick = mTicks[i]; 89 int x = tick&CHART_DATA_X_MASK; 90 int bin = (tick&CHART_DATA_BIN_MASK) >> CHART_DATA_BIN_SHIFT; 91 if (lastBin != 0) { 92 canvas.drawRect(lastX, top, x, bottom, mPaints[lastBin]); 93 } 94 lastBin = bin; 95 lastX = x; 96 } 97 98 } 99 } 100 101 static final int SANS = 1; 102 static final int SERIF = 2; 103 static final int MONOSPACE = 3; 104 105 static final int BATTERY_WARN = 29; 106 static final int BATTERY_CRITICAL = 14; 107 108 // First value if for phone off; first value is "scanning"; following values 109 // are battery stats signal strength buckets. 110 static final int NUM_PHONE_SIGNALS = 7; 111 112 final Paint mBatteryBackgroundPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 113 final Paint mBatteryGoodPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 114 final Paint mBatteryWarnPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 115 final Paint mBatteryCriticalPaint = new Paint(Paint.ANTI_ALIAS_FLAG); 116 final Paint mChargingPaint = new Paint(); 117 final Paint mScreenOnPaint = new Paint(); 118 final Paint mGpsOnPaint = new Paint(); 119 final Paint mWifiRunningPaint = new Paint(); 120 final Paint mWakeLockPaint = new Paint(); 121 final ChartData mPhoneSignalChart = new ChartData(); 122 final TextPaint mTextPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG); 123 124 final Path mBatLevelPath = new Path(); 125 final Path mBatGoodPath = new Path(); 126 final Path mBatWarnPath = new Path(); 127 final Path mBatCriticalPath = new Path(); 128 final Path mChargingPath = new Path(); 129 final Path mScreenOnPath = new Path(); 130 final Path mGpsOnPath = new Path(); 131 final Path mWifiRunningPath = new Path(); 132 final Path mWakeLockPath = new Path(); 133 134 int mFontSize; 135 136 BatteryStats mStats; 137 long mStatsPeriod; 138 String mDurationString; 139 String mTotalDurationString; 140 String mChargingLabel; 141 String mScreenOnLabel; 142 String mGpsOnLabel; 143 String mWifiRunningLabel; 144 String mWakeLockLabel; 145 String mPhoneSignalLabel; 146 147 int mTextAscent; 148 int mTextDescent; 149 int mDurationStringWidth; 150 int mTotalDurationStringWidth; 151 152 boolean mLargeMode; 153 154 int mLineWidth; 155 int mThinLineWidth; 156 int mChargingOffset; 157 int mScreenOnOffset; 158 int mGpsOnOffset; 159 int mWifiRunningOffset; 160 int mWakeLockOffset; 161 int mPhoneSignalOffset; 162 int mLevelOffset; 163 int mLevelTop; 164 int mLevelBottom; 165 static final int PHONE_SIGNAL_X_MASK = CHART_DATA_X_MASK; 166 static final int PHONE_SIGNAL_BIN_MASK = CHART_DATA_BIN_MASK; 167 static final int PHONE_SIGNAL_BIN_SHIFT = CHART_DATA_BIN_SHIFT; 168 169 int mNumHist; 170 long mHistStart; 171 long mHistEnd; 172 int mBatLow; 173 int mBatHigh; 174 boolean mHaveWifi; 175 boolean mHaveGps; 176 boolean mHavePhoneSignal; 177 178 public BatteryHistoryChart(Context context, AttributeSet attrs) { 179 super(context, attrs); 180 181 mBatteryBackgroundPaint.setARGB(255, 128, 128, 128); 182 mBatteryBackgroundPaint.setStyle(Paint.Style.FILL); 183 mBatteryGoodPaint.setARGB(128, 0, 255, 0); 184 mBatteryGoodPaint.setStyle(Paint.Style.STROKE); 185 mBatteryWarnPaint.setARGB(128, 255, 255, 0); 186 mBatteryWarnPaint.setStyle(Paint.Style.STROKE); 187 mBatteryCriticalPaint.setARGB(192, 255, 0, 0); 188 mBatteryCriticalPaint.setStyle(Paint.Style.STROKE); 189 mChargingPaint.setARGB(255, 0, 128, 0); 190 mChargingPaint.setStyle(Paint.Style.STROKE); 191 mScreenOnPaint.setStyle(Paint.Style.STROKE); 192 mGpsOnPaint.setStyle(Paint.Style.STROKE); 193 mWifiRunningPaint.setStyle(Paint.Style.STROKE); 194 mWakeLockPaint.setStyle(Paint.Style.STROKE); 195 mPhoneSignalChart.setColors(new int[] { 196 0x00000000, 0xffa00000, 0xffa0a000, 0xff808020, 197 0xff808040, 0xff808060, 0xff008000 198 }); 199 200 mTextPaint.density = getResources().getDisplayMetrics().density; 201 mTextPaint.setCompatibilityScaling( 202 getResources().getCompatibilityInfo().applicationScale); 203 204 TypedArray a = 205 context.obtainStyledAttributes( 206 attrs, R.styleable.BatteryHistoryChart, 0, 0); 207 208 ColorStateList textColor = null; 209 int textSize = 15; 210 int typefaceIndex = -1; 211 int styleIndex = -1; 212 213 TypedArray appearance = null; 214 int ap = a.getResourceId(R.styleable.BatteryHistoryChart_android_textAppearance, -1); 215 if (ap != -1) { 216 appearance = context.obtainStyledAttributes(ap, 217 com.android.internal.R.styleable. 218 TextAppearance); 219 } 220 if (appearance != null) { 221 int n = appearance.getIndexCount(); 222 for (int i = 0; i < n; i++) { 223 int attr = appearance.getIndex(i); 224 225 switch (attr) { 226 case com.android.internal.R.styleable.TextAppearance_textColor: 227 textColor = appearance.getColorStateList(attr); 228 break; 229 230 case com.android.internal.R.styleable.TextAppearance_textSize: 231 textSize = appearance.getDimensionPixelSize(attr, textSize); 232 break; 233 234 case com.android.internal.R.styleable.TextAppearance_typeface: 235 typefaceIndex = appearance.getInt(attr, -1); 236 break; 237 238 case com.android.internal.R.styleable.TextAppearance_textStyle: 239 styleIndex = appearance.getInt(attr, -1); 240 break; 241 } 242 } 243 244 appearance.recycle(); 245 } 246 247 int shadowcolor = 0; 248 float dx=0, dy=0, r=0; 249 250 int n = a.getIndexCount(); 251 for (int i = 0; i < n; i++) { 252 int attr = a.getIndex(i); 253 254 switch (attr) { 255 case R.styleable.BatteryHistoryChart_android_shadowColor: 256 shadowcolor = a.getInt(attr, 0); 257 break; 258 259 case R.styleable.BatteryHistoryChart_android_shadowDx: 260 dx = a.getFloat(attr, 0); 261 break; 262 263 case R.styleable.BatteryHistoryChart_android_shadowDy: 264 dy = a.getFloat(attr, 0); 265 break; 266 267 case R.styleable.BatteryHistoryChart_android_shadowRadius: 268 r = a.getFloat(attr, 0); 269 break; 270 271 case R.styleable.BatteryHistoryChart_android_textColor: 272 textColor = a.getColorStateList(attr); 273 break; 274 275 case R.styleable.BatteryHistoryChart_android_textSize: 276 textSize = a.getDimensionPixelSize(attr, textSize); 277 break; 278 279 case R.styleable.BatteryHistoryChart_android_typeface: 280 typefaceIndex = a.getInt(attr, typefaceIndex); 281 break; 282 283 case R.styleable.BatteryHistoryChart_android_textStyle: 284 styleIndex = a.getInt(attr, styleIndex); 285 break; 286 } 287 } 288 289 a.recycle(); 290 291 mTextPaint.setColor(textColor.getDefaultColor()); 292 mTextPaint.setTextSize(textSize); 293 294 Typeface tf = null; 295 switch (typefaceIndex) { 296 case SANS: 297 tf = Typeface.SANS_SERIF; 298 break; 299 300 case SERIF: 301 tf = Typeface.SERIF; 302 break; 303 304 case MONOSPACE: 305 tf = Typeface.MONOSPACE; 306 break; 307 } 308 309 setTypeface(tf, styleIndex); 310 311 if (shadowcolor != 0) { 312 mTextPaint.setShadowLayer(r, dx, dy, shadowcolor); 313 } 314 } 315 316 public void setTypeface(Typeface tf, int style) { 317 if (style > 0) { 318 if (tf == null) { 319 tf = Typeface.defaultFromStyle(style); 320 } else { 321 tf = Typeface.create(tf, style); 322 } 323 324 mTextPaint.setTypeface(tf); 325 // now compute what (if any) algorithmic styling is needed 326 int typefaceStyle = tf != null ? tf.getStyle() : 0; 327 int need = style & ~typefaceStyle; 328 mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0); 329 mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0); 330 } else { 331 mTextPaint.setFakeBoldText(false); 332 mTextPaint.setTextSkewX(0); 333 mTextPaint.setTypeface(tf); 334 } 335 } 336 337 void setStats(BatteryStats stats) { 338 mStats = stats; 339 340 long uSecTime = mStats.computeBatteryRealtime(SystemClock.elapsedRealtime() * 1000, 341 BatteryStats.STATS_SINCE_CHARGED); 342 mStatsPeriod = uSecTime; 343 String durationString = Utils.formatElapsedTime(getContext(), mStatsPeriod / 1000); 344 mDurationString = getContext().getString(R.string.battery_stats_on_battery, 345 durationString); 346 mChargingLabel = getContext().getString(R.string.battery_stats_charging_label); 347 mScreenOnLabel = getContext().getString(R.string.battery_stats_screen_on_label); 348 mGpsOnLabel = getContext().getString(R.string.battery_stats_gps_on_label); 349 mWifiRunningLabel = getContext().getString(R.string.battery_stats_wifi_running_label); 350 mWakeLockLabel = getContext().getString(R.string.battery_stats_wake_lock_label); 351 mPhoneSignalLabel = getContext().getString(R.string.battery_stats_phone_signal_label); 352 353 int pos = 0; 354 int lastInteresting = 0; 355 byte lastLevel = -1; 356 mBatLow = 0; 357 mBatHigh = 100; 358 int aggrStates = 0; 359 boolean first = true; 360 if (stats.startIteratingHistoryLocked()) { 361 final HistoryItem rec = new HistoryItem(); 362 while (stats.getNextHistoryLocked(rec)) { 363 pos++; 364 if (rec.cmd == HistoryItem.CMD_UPDATE) { 365 if (first) { 366 first = false; 367 mHistStart = rec.time; 368 } 369 if (rec.batteryLevel != lastLevel || pos == 1) { 370 lastLevel = rec.batteryLevel; 371 } 372 lastInteresting = pos; 373 mHistEnd = rec.time; 374 aggrStates |= rec.states; 375 } 376 } 377 } 378 mNumHist = lastInteresting; 379 mHaveGps = (aggrStates&HistoryItem.STATE_GPS_ON_FLAG) != 0; 380 mHaveWifi = (aggrStates&HistoryItem.STATE_WIFI_RUNNING_FLAG) != 0; 381 if (!com.android.settings.Utils.isWifiOnly(getContext())) { 382 mHavePhoneSignal = true; 383 } 384 if (mHistEnd <= mHistStart) mHistEnd = mHistStart+1; 385 mTotalDurationString = Utils.formatElapsedTime(getContext(), mHistEnd - mHistStart); 386 } 387 388 @Override 389 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 390 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 391 mDurationStringWidth = (int)mTextPaint.measureText(mDurationString); 392 mTotalDurationStringWidth = (int)mTextPaint.measureText(mTotalDurationString); 393 mTextAscent = (int)mTextPaint.ascent(); 394 mTextDescent = (int)mTextPaint.descent(); 395 } 396 397 void finishPaths(int w, int h, int levelh, int startX, int y, Path curLevelPath, 398 int lastX, boolean lastCharging, boolean lastScreenOn, boolean lastGpsOn, 399 boolean lastWifiRunning, boolean lastWakeLock, Path lastPath) { 400 if (curLevelPath != null) { 401 if (lastX >= 0 && lastX < w) { 402 if (lastPath != null) { 403 lastPath.lineTo(w, y); 404 } 405 curLevelPath.lineTo(w, y); 406 } 407 curLevelPath.lineTo(w, mLevelTop+levelh); 408 curLevelPath.lineTo(startX, mLevelTop+levelh); 409 curLevelPath.close(); 410 } 411 412 if (lastCharging) { 413 mChargingPath.lineTo(w, h-mChargingOffset); 414 } 415 if (lastScreenOn) { 416 mScreenOnPath.lineTo(w, h-mScreenOnOffset); 417 } 418 if (lastGpsOn) { 419 mGpsOnPath.lineTo(w, h-mGpsOnOffset); 420 } 421 if (lastWifiRunning) { 422 mWifiRunningPath.lineTo(w, h-mWifiRunningOffset); 423 } 424 if (lastWakeLock) { 425 mWakeLockPath.lineTo(w, h-mWakeLockOffset); 426 } 427 if (mHavePhoneSignal) { 428 mPhoneSignalChart.finish(w); 429 } 430 } 431 432 @Override 433 protected void onSizeChanged(int w, int h, int oldw, int oldh) { 434 super.onSizeChanged(w, h, oldw, oldh); 435 436 int textHeight = mTextDescent - mTextAscent; 437 mThinLineWidth = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 438 2, getResources().getDisplayMetrics()); 439 if (h > (textHeight*6)) { 440 mLargeMode = true; 441 if (h > (textHeight*15)) { 442 // Plenty of room for the chart. 443 mLineWidth = textHeight/2; 444 } else { 445 // Compress lines to make more room for chart. 446 mLineWidth = textHeight/3; 447 } 448 mLevelTop = textHeight + mLineWidth; 449 mScreenOnPaint.setARGB(255, 32, 64, 255); 450 mGpsOnPaint.setARGB(255, 32, 64, 255); 451 mWifiRunningPaint.setARGB(255, 32, 64, 255); 452 mWakeLockPaint.setARGB(255, 32, 64, 255); 453 } else { 454 mLargeMode = false; 455 mLineWidth = mThinLineWidth; 456 mLevelTop = 0; 457 mScreenOnPaint.setARGB(255, 0, 0, 255); 458 mGpsOnPaint.setARGB(255, 0, 0, 255); 459 mWifiRunningPaint.setARGB(255, 0, 0, 255); 460 mWakeLockPaint.setARGB(255, 0, 0, 255); 461 } 462 if (mLineWidth <= 0) mLineWidth = 1; 463 mTextPaint.setStrokeWidth(mThinLineWidth); 464 mBatteryGoodPaint.setStrokeWidth(mThinLineWidth); 465 mBatteryWarnPaint.setStrokeWidth(mThinLineWidth); 466 mBatteryCriticalPaint.setStrokeWidth(mThinLineWidth); 467 mChargingPaint.setStrokeWidth(mLineWidth); 468 mScreenOnPaint.setStrokeWidth(mLineWidth); 469 mGpsOnPaint.setStrokeWidth(mLineWidth); 470 mWifiRunningPaint.setStrokeWidth(mLineWidth); 471 mWakeLockPaint.setStrokeWidth(mLineWidth); 472 473 if (mLargeMode) { 474 int barOffset = textHeight + mLineWidth; 475 mChargingOffset = mLineWidth; 476 mScreenOnOffset = mChargingOffset + barOffset; 477 mWakeLockOffset = mScreenOnOffset + barOffset; 478 mWifiRunningOffset = mWakeLockOffset + barOffset; 479 mGpsOnOffset = mWifiRunningOffset + (mHaveWifi ? barOffset : 0); 480 mPhoneSignalOffset = mGpsOnOffset + (mHaveGps ? barOffset : 0); 481 mLevelOffset = mPhoneSignalOffset + (mHavePhoneSignal ? barOffset : 0) 482 + ((mLineWidth*3)/2); 483 if (mHavePhoneSignal) { 484 mPhoneSignalChart.init(w); 485 } 486 } else { 487 mScreenOnOffset = mGpsOnOffset = mWifiRunningOffset 488 = mWakeLockOffset = mLineWidth; 489 mChargingOffset = mLineWidth*2; 490 mPhoneSignalOffset = 0; 491 mLevelOffset = mLineWidth*3; 492 if (mHavePhoneSignal) { 493 mPhoneSignalChart.init(0); 494 } 495 } 496 497 mBatLevelPath.reset(); 498 mBatGoodPath.reset(); 499 mBatWarnPath.reset(); 500 mBatCriticalPath.reset(); 501 mScreenOnPath.reset(); 502 mGpsOnPath.reset(); 503 mWifiRunningPath.reset(); 504 mWakeLockPath.reset(); 505 mChargingPath.reset(); 506 507 final long timeStart = mHistStart; 508 final long timeChange = mHistEnd-mHistStart; 509 510 final int batLow = mBatLow; 511 final int batChange = mBatHigh-mBatLow; 512 513 final int levelh = h - mLevelOffset - mLevelTop; 514 mLevelBottom = mLevelTop + levelh; 515 516 int x = 0, y = 0, startX = 0, lastX = -1, lastY = -1; 517 int i = 0; 518 Path curLevelPath = null; 519 Path lastLinePath = null; 520 boolean lastCharging = false, lastScreenOn = false, lastGpsOn = false; 521 boolean lastWifiRunning = false, lastWakeLock = false; 522 final int N = mNumHist; 523 if (mStats.startIteratingHistoryLocked()) { 524 final HistoryItem rec = new HistoryItem(); 525 while (mStats.getNextHistoryLocked(rec) && i < N) { 526 if (rec.cmd == BatteryStats.HistoryItem.CMD_UPDATE) { 527 x = (int)(((rec.time-timeStart)*w)/timeChange); 528 y = mLevelTop + levelh - ((rec.batteryLevel-batLow)*(levelh-1))/batChange; 529 530 if (lastX != x) { 531 // We have moved by at least a pixel. 532 if (lastY != y) { 533 // Don't plot changes within a pixel. 534 Path path; 535 byte value = rec.batteryLevel; 536 if (value <= BATTERY_CRITICAL) path = mBatCriticalPath; 537 else if (value <= BATTERY_WARN) path = mBatWarnPath; 538 else path = mBatGoodPath; 539 540 if (path != lastLinePath) { 541 if (lastLinePath != null) { 542 lastLinePath.lineTo(x, y); 543 } 544 path.moveTo(x, y); 545 lastLinePath = path; 546 } else { 547 path.lineTo(x, y); 548 } 549 550 if (curLevelPath == null) { 551 curLevelPath = mBatLevelPath; 552 curLevelPath.moveTo(x, y); 553 startX = x; 554 } else { 555 curLevelPath.lineTo(x, y); 556 } 557 lastX = x; 558 lastY = y; 559 } 560 } 561 562 final boolean charging = 563 (rec.states&HistoryItem.STATE_BATTERY_PLUGGED_FLAG) != 0; 564 if (charging != lastCharging) { 565 if (charging) { 566 mChargingPath.moveTo(x, h-mChargingOffset); 567 } else { 568 mChargingPath.lineTo(x, h-mChargingOffset); 569 } 570 lastCharging = charging; 571 } 572 573 final boolean screenOn = 574 (rec.states&HistoryItem.STATE_SCREEN_ON_FLAG) != 0; 575 if (screenOn != lastScreenOn) { 576 if (screenOn) { 577 mScreenOnPath.moveTo(x, h-mScreenOnOffset); 578 } else { 579 mScreenOnPath.lineTo(x, h-mScreenOnOffset); 580 } 581 lastScreenOn = screenOn; 582 } 583 584 final boolean gpsOn = 585 (rec.states&HistoryItem.STATE_GPS_ON_FLAG) != 0; 586 if (gpsOn != lastGpsOn) { 587 if (gpsOn) { 588 mGpsOnPath.moveTo(x, h-mGpsOnOffset); 589 } else { 590 mGpsOnPath.lineTo(x, h-mGpsOnOffset); 591 } 592 lastGpsOn = gpsOn; 593 } 594 595 final boolean wifiRunning = 596 (rec.states&HistoryItem.STATE_WIFI_RUNNING_FLAG) != 0; 597 if (wifiRunning != lastWifiRunning) { 598 if (wifiRunning) { 599 mWifiRunningPath.moveTo(x, h-mWifiRunningOffset); 600 } else { 601 mWifiRunningPath.lineTo(x, h-mWifiRunningOffset); 602 } 603 lastWifiRunning = wifiRunning; 604 } 605 606 final boolean wakeLock = 607 (rec.states&HistoryItem.STATE_WAKE_LOCK_FLAG) != 0; 608 if (wakeLock != lastWakeLock) { 609 if (wakeLock) { 610 mWakeLockPath.moveTo(x, h-mWakeLockOffset); 611 } else { 612 mWakeLockPath.lineTo(x, h-mWakeLockOffset); 613 } 614 lastWakeLock = wakeLock; 615 } 616 617 if (mLargeMode && mHavePhoneSignal) { 618 int bin; 619 if (((rec.states&HistoryItem.STATE_PHONE_STATE_MASK) 620 >> HistoryItem.STATE_PHONE_STATE_SHIFT) 621 == ServiceState.STATE_POWER_OFF) { 622 bin = 0; 623 } else if ((rec.states&HistoryItem.STATE_PHONE_SCANNING_FLAG) != 0) { 624 bin = 1; 625 } else { 626 bin = (rec.states&HistoryItem.STATE_SIGNAL_STRENGTH_MASK) 627 >> HistoryItem.STATE_SIGNAL_STRENGTH_SHIFT; 628 bin += 2; 629 } 630 mPhoneSignalChart.addTick(x, bin); 631 } 632 633 } else if (rec.cmd != BatteryStats.HistoryItem.CMD_OVERFLOW) { 634 if (curLevelPath != null) { 635 finishPaths(x+1, h, levelh, startX, lastY, curLevelPath, lastX, 636 lastCharging, lastScreenOn, lastGpsOn, lastWifiRunning, 637 lastWakeLock, lastLinePath); 638 lastX = lastY = -1; 639 curLevelPath = null; 640 lastLinePath = null; 641 lastCharging = lastScreenOn = lastGpsOn = lastWakeLock = false; 642 } 643 } 644 645 i++; 646 } 647 } 648 649 finishPaths(w, h, levelh, startX, lastY, curLevelPath, lastX, 650 lastCharging, lastScreenOn, lastGpsOn, lastWifiRunning, 651 lastWakeLock, lastLinePath); 652 } 653 654 @Override 655 protected void onDraw(Canvas canvas) { 656 super.onDraw(canvas); 657 658 final int width = getWidth(); 659 final int height = getHeight(); 660 661 canvas.drawPath(mBatLevelPath, mBatteryBackgroundPaint); 662 if (mLargeMode) { 663 canvas.drawText(mDurationString, 0, -mTextAscent + (mLineWidth/2), 664 mTextPaint); 665 canvas.drawText(mTotalDurationString, (width/2) - (mTotalDurationStringWidth/2), 666 mLevelBottom - mTextAscent + mThinLineWidth, mTextPaint); 667 } else { 668 canvas.drawText(mDurationString, (width/2) - (mDurationStringWidth/2), 669 (height/2) - ((mTextDescent-mTextAscent)/2) - mTextAscent, mTextPaint); 670 } 671 if (!mBatGoodPath.isEmpty()) { 672 canvas.drawPath(mBatGoodPath, mBatteryGoodPaint); 673 } 674 if (!mBatWarnPath.isEmpty()) { 675 canvas.drawPath(mBatWarnPath, mBatteryWarnPaint); 676 } 677 if (!mBatCriticalPath.isEmpty()) { 678 canvas.drawPath(mBatCriticalPath, mBatteryCriticalPaint); 679 } 680 if (mHavePhoneSignal) { 681 int top = height-mPhoneSignalOffset - (mLineWidth/2); 682 mPhoneSignalChart.draw(canvas, top, mLineWidth); 683 } 684 if (!mScreenOnPath.isEmpty()) { 685 canvas.drawPath(mScreenOnPath, mScreenOnPaint); 686 } 687 if (!mChargingPath.isEmpty()) { 688 canvas.drawPath(mChargingPath, mChargingPaint); 689 } 690 if (mHaveGps) { 691 if (!mGpsOnPath.isEmpty()) { 692 canvas.drawPath(mGpsOnPath, mGpsOnPaint); 693 } 694 } 695 if (mHaveWifi) { 696 if (!mWifiRunningPath.isEmpty()) { 697 canvas.drawPath(mWifiRunningPath, mWifiRunningPaint); 698 } 699 } 700 if (!mWakeLockPath.isEmpty()) { 701 canvas.drawPath(mWakeLockPath, mWakeLockPaint); 702 } 703 704 if (mLargeMode) { 705 if (mHavePhoneSignal) { 706 canvas.drawText(mPhoneSignalLabel, 0, 707 height - mPhoneSignalOffset - mTextDescent, mTextPaint); 708 } 709 if (mHaveGps) { 710 canvas.drawText(mGpsOnLabel, 0, 711 height - mGpsOnOffset - mTextDescent, mTextPaint); 712 } 713 if (mHaveWifi) { 714 canvas.drawText(mWifiRunningLabel, 0, 715 height - mWifiRunningOffset - mTextDescent, mTextPaint); 716 } 717 canvas.drawText(mWakeLockLabel, 0, 718 height - mWakeLockOffset - mTextDescent, mTextPaint); 719 canvas.drawText(mChargingLabel, 0, 720 height - mChargingOffset - mTextDescent, mTextPaint); 721 canvas.drawText(mScreenOnLabel, 0, 722 height - mScreenOnOffset - mTextDescent, mTextPaint); 723 canvas.drawLine(0, mLevelBottom+(mThinLineWidth/2), width, 724 mLevelBottom+(mThinLineWidth/2), mTextPaint); 725 canvas.drawLine(0, mLevelTop, 0, 726 mLevelBottom+(mThinLineWidth/2), mTextPaint); 727 for (int i=0; i<10; i++) { 728 int y = mLevelTop + ((mLevelBottom-mLevelTop)*i)/10; 729 canvas.drawLine(0, y, mThinLineWidth*2, y, mTextPaint); 730 } 731 } 732 } 733 } 734