1 /* 2 * Copyright (C) 2006-2007 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.server.am; 18 19 import android.annotation.Nullable; 20 import android.bluetooth.BluetoothActivityEnergyInfo; 21 import android.bluetooth.BluetoothAdapter; 22 import android.content.Context; 23 import android.content.pm.ApplicationInfo; 24 import android.content.pm.PackageManager; 25 import android.net.wifi.IWifiManager; 26 import android.net.wifi.WifiActivityEnergyInfo; 27 import android.os.BatteryStats; 28 import android.os.Binder; 29 import android.os.Handler; 30 import android.os.IBinder; 31 import android.os.Looper; 32 import android.os.Message; 33 import android.os.Parcel; 34 import android.os.ParcelFileDescriptor; 35 import android.os.ParcelFormatException; 36 import android.os.Parcelable; 37 import android.os.PowerManagerInternal; 38 import android.os.Process; 39 import android.os.RemoteException; 40 import android.os.ServiceManager; 41 import android.os.SynchronousResultReceiver; 42 import android.os.SystemClock; 43 import android.os.UserHandle; 44 import android.os.WorkSource; 45 import android.os.health.HealthStatsParceler; 46 import android.os.health.HealthStatsWriter; 47 import android.os.health.UidHealthStats; 48 import android.telephony.DataConnectionRealTimeInfo; 49 import android.telephony.ModemActivityInfo; 50 import android.telephony.SignalStrength; 51 import android.telephony.TelephonyManager; 52 import android.util.IntArray; 53 import android.util.Slog; 54 55 import android.util.TimeUtils; 56 import com.android.internal.annotations.GuardedBy; 57 import com.android.internal.app.IBatteryStats; 58 import com.android.internal.os.BatteryStatsHelper; 59 import com.android.internal.os.BatteryStatsImpl; 60 import com.android.internal.os.PowerProfile; 61 import com.android.server.LocalServices; 62 import com.android.server.ServiceThread; 63 64 import java.io.File; 65 import java.io.FileDescriptor; 66 import java.io.IOException; 67 import java.io.PrintWriter; 68 import java.nio.ByteBuffer; 69 import java.nio.CharBuffer; 70 import java.nio.charset.CharsetDecoder; 71 import java.nio.charset.CodingErrorAction; 72 import java.nio.charset.StandardCharsets; 73 import java.util.Arrays; 74 import java.util.List; 75 import java.util.concurrent.TimeoutException; 76 77 /** 78 * All information we are collecting about things that can happen that impact 79 * battery life. 80 */ 81 public final class BatteryStatsService extends IBatteryStats.Stub 82 implements PowerManagerInternal.LowPowerModeListener, 83 BatteryStatsImpl.PlatformIdleStateCallback { 84 static final String TAG = "BatteryStatsService"; 85 86 /** 87 * How long to wait on an individual subsystem to return its stats. 88 */ 89 private static final long EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS = 2000; 90 91 // There is some accuracy error in wifi reports so allow some slop in the results. 92 private static final long MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS = 750; 93 94 private static IBatteryStats sService; 95 96 final BatteryStatsImpl mStats; 97 private final BatteryStatsHandler mHandler; 98 private Context mContext; 99 private IWifiManager mWifiManager; 100 private TelephonyManager mTelephony; 101 102 // Lock acquired when extracting data from external sources. 103 private final Object mExternalStatsLock = new Object(); 104 105 // WiFi keeps an accumulated total of stats, unlike Bluetooth. 106 // Keep the last WiFi stats so we can compute a delta. 107 @GuardedBy("mExternalStatsLock") 108 private WifiActivityEnergyInfo mLastInfo = 109 new WifiActivityEnergyInfo(0, 0, 0, new long[]{0}, 0, 0, 0); 110 111 class BatteryStatsHandler extends Handler implements BatteryStatsImpl.ExternalStatsSync { 112 public static final int MSG_SYNC_EXTERNAL_STATS = 1; 113 public static final int MSG_WRITE_TO_DISK = 2; 114 115 private int mUpdateFlags = 0; 116 private IntArray mUidsToRemove = new IntArray(); 117 118 public BatteryStatsHandler(Looper looper) { 119 super(looper); 120 } 121 122 @Override 123 public void handleMessage(Message msg) { 124 switch (msg.what) { 125 case MSG_SYNC_EXTERNAL_STATS: 126 final int updateFlags; 127 synchronized (this) { 128 removeMessages(MSG_SYNC_EXTERNAL_STATS); 129 updateFlags = mUpdateFlags; 130 mUpdateFlags = 0; 131 } 132 updateExternalStatsSync((String)msg.obj, updateFlags); 133 134 // other parts of the system could be calling into us 135 // from mStats in order to report of changes. We must grab the mStats 136 // lock before grabbing our own or we'll end up in a deadlock. 137 synchronized (mStats) { 138 synchronized (this) { 139 final int numUidsToRemove = mUidsToRemove.size(); 140 for (int i = 0; i < numUidsToRemove; i++) { 141 mStats.removeIsolatedUidLocked(mUidsToRemove.get(i)); 142 } 143 } 144 mUidsToRemove.clear(); 145 } 146 break; 147 148 case MSG_WRITE_TO_DISK: 149 updateExternalStatsSync("write", UPDATE_ALL); 150 synchronized (mStats) { 151 mStats.writeAsyncLocked(); 152 } 153 break; 154 } 155 } 156 157 @Override 158 public void scheduleSync(String reason, int updateFlags) { 159 synchronized (this) { 160 scheduleSyncLocked(reason, updateFlags); 161 } 162 } 163 164 @Override 165 public void scheduleCpuSyncDueToRemovedUid(int uid) { 166 synchronized (this) { 167 scheduleSyncLocked("remove-uid", UPDATE_CPU); 168 mUidsToRemove.add(uid); 169 } 170 } 171 172 private void scheduleSyncLocked(String reason, int updateFlags) { 173 if (mUpdateFlags == 0) { 174 sendMessage(Message.obtain(this, MSG_SYNC_EXTERNAL_STATS, reason)); 175 } 176 mUpdateFlags |= updateFlags; 177 } 178 } 179 180 private native int getPlatformLowPowerStats(ByteBuffer outBuffer); 181 private CharsetDecoder mDecoderStat = StandardCharsets.UTF_8 182 .newDecoder() 183 .onMalformedInput(CodingErrorAction.REPLACE) 184 .onUnmappableCharacter(CodingErrorAction.REPLACE) 185 .replaceWith("?"); 186 private ByteBuffer mUtf8BufferStat = ByteBuffer.allocateDirect(MAX_LOW_POWER_STATS_SIZE); 187 private CharBuffer mUtf16BufferStat = CharBuffer.allocate(MAX_LOW_POWER_STATS_SIZE); 188 private static final int MAX_LOW_POWER_STATS_SIZE = 512; 189 190 @Override 191 public String getPlatformLowPowerStats() { 192 mUtf8BufferStat.clear(); 193 mUtf16BufferStat.clear(); 194 mDecoderStat.reset(); 195 int bytesWritten = getPlatformLowPowerStats(mUtf8BufferStat); 196 if (bytesWritten < 0) { 197 return null; 198 } else if (bytesWritten == 0) { 199 return "Empty"; 200 } 201 mUtf8BufferStat.limit(bytesWritten); 202 mDecoderStat.decode(mUtf8BufferStat, mUtf16BufferStat, true); 203 mUtf16BufferStat.flip(); 204 return mUtf16BufferStat.toString(); 205 } 206 207 BatteryStatsService(File systemDir, Handler handler) { 208 // Our handler here will be accessing the disk, use a different thread than 209 // what the ActivityManagerService gave us (no I/O on that one!). 210 final ServiceThread thread = new ServiceThread("batterystats-sync", 211 Process.THREAD_PRIORITY_DEFAULT, true); 212 thread.start(); 213 mHandler = new BatteryStatsHandler(thread.getLooper()); 214 215 // BatteryStatsImpl expects the ActivityManagerService handler, so pass that one through. 216 mStats = new BatteryStatsImpl(systemDir, handler, mHandler, this); 217 } 218 219 public void publish(Context context) { 220 mContext = context; 221 mStats.setRadioScanningTimeout(mContext.getResources().getInteger( 222 com.android.internal.R.integer.config_radioScanningTimeout) 223 * 1000L); 224 mStats.setPowerProfile(new PowerProfile(context)); 225 ServiceManager.addService(BatteryStats.SERVICE_NAME, asBinder()); 226 } 227 228 /** 229 * At the time when the constructor runs, the power manager has not yet been 230 * initialized. So we initialize the low power observer later. 231 */ 232 public void initPowerManagement() { 233 final PowerManagerInternal powerMgr = LocalServices.getService(PowerManagerInternal.class); 234 powerMgr.registerLowPowerModeObserver(this); 235 mStats.notePowerSaveMode(powerMgr.getLowPowerModeEnabled()); 236 (new WakeupReasonThread()).start(); 237 } 238 239 public void shutdown() { 240 Slog.w("BatteryStats", "Writing battery stats before shutdown..."); 241 242 updateExternalStatsSync("shutdown", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 243 synchronized (mStats) { 244 mStats.shutdownLocked(); 245 } 246 247 // Shutdown the thread we made. 248 mHandler.getLooper().quit(); 249 } 250 251 public static IBatteryStats getService() { 252 if (sService != null) { 253 return sService; 254 } 255 IBinder b = ServiceManager.getService(BatteryStats.SERVICE_NAME); 256 sService = asInterface(b); 257 return sService; 258 } 259 260 @Override 261 public void onLowPowerModeChanged(boolean enabled) { 262 synchronized (mStats) { 263 mStats.notePowerSaveMode(enabled); 264 } 265 } 266 267 /** 268 * @return the current statistics object, which may be modified 269 * to reflect events that affect battery usage. You must lock the 270 * stats object before doing anything with it. 271 */ 272 public BatteryStatsImpl getActiveStatistics() { 273 return mStats; 274 } 275 276 /** 277 * Schedules a write to disk to occur. This will cause the BatteryStatsImpl 278 * object to update with the latest info, then write to disk. 279 */ 280 public void scheduleWriteToDisk() { 281 mHandler.sendEmptyMessage(BatteryStatsHandler.MSG_WRITE_TO_DISK); 282 } 283 284 // These are for direct use by the activity manager... 285 286 /** 287 * Remove a UID from the BatteryStats and BatteryStats' external dependencies. 288 */ 289 void removeUid(int uid) { 290 synchronized (mStats) { 291 mStats.removeUidStatsLocked(uid); 292 } 293 } 294 295 void addIsolatedUid(int isolatedUid, int appUid) { 296 synchronized (mStats) { 297 mStats.addIsolatedUidLocked(isolatedUid, appUid); 298 } 299 } 300 301 void removeIsolatedUid(int isolatedUid, int appUid) { 302 synchronized (mStats) { 303 mStats.scheduleRemoveIsolatedUidLocked(isolatedUid, appUid); 304 } 305 } 306 307 void noteProcessStart(String name, int uid) { 308 synchronized (mStats) { 309 mStats.noteProcessStartLocked(name, uid); 310 } 311 } 312 313 void noteProcessCrash(String name, int uid) { 314 synchronized (mStats) { 315 mStats.noteProcessCrashLocked(name, uid); 316 } 317 } 318 319 void noteProcessAnr(String name, int uid) { 320 synchronized (mStats) { 321 mStats.noteProcessAnrLocked(name, uid); 322 } 323 } 324 325 void noteProcessFinish(String name, int uid) { 326 synchronized (mStats) { 327 mStats.noteProcessFinishLocked(name, uid); 328 } 329 } 330 331 void noteUidProcessState(int uid, int state) { 332 synchronized (mStats) { 333 mStats.noteUidProcessStateLocked(uid, state); 334 } 335 } 336 337 // Public interface... 338 339 public byte[] getStatistics() { 340 mContext.enforceCallingPermission( 341 android.Manifest.permission.BATTERY_STATS, null); 342 //Slog.i("foo", "SENDING BATTERY INFO:"); 343 //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo", Log.LOG_ID_SYSTEM)); 344 Parcel out = Parcel.obtain(); 345 updateExternalStatsSync("get-stats", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 346 synchronized (mStats) { 347 mStats.writeToParcel(out, 0); 348 } 349 byte[] data = out.marshall(); 350 out.recycle(); 351 return data; 352 } 353 354 public ParcelFileDescriptor getStatisticsStream() { 355 mContext.enforceCallingPermission( 356 android.Manifest.permission.BATTERY_STATS, null); 357 //Slog.i("foo", "SENDING BATTERY INFO:"); 358 //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo", Log.LOG_ID_SYSTEM)); 359 Parcel out = Parcel.obtain(); 360 updateExternalStatsSync("get-stats", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 361 synchronized (mStats) { 362 mStats.writeToParcel(out, 0); 363 } 364 byte[] data = out.marshall(); 365 out.recycle(); 366 try { 367 return ParcelFileDescriptor.fromData(data, "battery-stats"); 368 } catch (IOException e) { 369 Slog.w(TAG, "Unable to create shared memory", e); 370 return null; 371 } 372 } 373 374 public boolean isCharging() { 375 synchronized (mStats) { 376 return mStats.isCharging(); 377 } 378 } 379 380 public long computeBatteryTimeRemaining() { 381 synchronized (mStats) { 382 long time = mStats.computeBatteryTimeRemaining(SystemClock.elapsedRealtime()); 383 return time >= 0 ? (time/1000) : time; 384 } 385 } 386 387 public long computeChargeTimeRemaining() { 388 synchronized (mStats) { 389 long time = mStats.computeChargeTimeRemaining(SystemClock.elapsedRealtime()); 390 return time >= 0 ? (time/1000) : time; 391 } 392 } 393 394 public void noteEvent(int code, String name, int uid) { 395 enforceCallingPermission(); 396 synchronized (mStats) { 397 mStats.noteEventLocked(code, name, uid); 398 } 399 } 400 401 public void noteSyncStart(String name, int uid) { 402 enforceCallingPermission(); 403 synchronized (mStats) { 404 mStats.noteSyncStartLocked(name, uid); 405 } 406 } 407 408 public void noteSyncFinish(String name, int uid) { 409 enforceCallingPermission(); 410 synchronized (mStats) { 411 mStats.noteSyncFinishLocked(name, uid); 412 } 413 } 414 415 public void noteJobStart(String name, int uid) { 416 enforceCallingPermission(); 417 synchronized (mStats) { 418 mStats.noteJobStartLocked(name, uid); 419 } 420 } 421 422 public void noteJobFinish(String name, int uid) { 423 enforceCallingPermission(); 424 synchronized (mStats) { 425 mStats.noteJobFinishLocked(name, uid); 426 } 427 } 428 429 public void noteAlarmStart(String name, int uid) { 430 enforceCallingPermission(); 431 synchronized (mStats) { 432 mStats.noteAlarmStartLocked(name, uid); 433 } 434 } 435 436 public void noteAlarmFinish(String name, int uid) { 437 enforceCallingPermission(); 438 synchronized (mStats) { 439 mStats.noteAlarmFinishLocked(name, uid); 440 } 441 } 442 443 public void noteStartWakelock(int uid, int pid, String name, String historyName, int type, 444 boolean unimportantForLogging) { 445 enforceCallingPermission(); 446 synchronized (mStats) { 447 mStats.noteStartWakeLocked(uid, pid, name, historyName, type, unimportantForLogging, 448 SystemClock.elapsedRealtime(), SystemClock.uptimeMillis()); 449 } 450 } 451 452 public void noteStopWakelock(int uid, int pid, String name, String historyName, int type) { 453 enforceCallingPermission(); 454 synchronized (mStats) { 455 mStats.noteStopWakeLocked(uid, pid, name, historyName, type, 456 SystemClock.elapsedRealtime(), SystemClock.uptimeMillis()); 457 } 458 } 459 460 public void noteStartWakelockFromSource(WorkSource ws, int pid, String name, 461 String historyName, int type, boolean unimportantForLogging) { 462 enforceCallingPermission(); 463 synchronized (mStats) { 464 mStats.noteStartWakeFromSourceLocked(ws, pid, name, historyName, 465 type, unimportantForLogging); 466 } 467 } 468 469 public void noteChangeWakelockFromSource(WorkSource ws, int pid, String name, 470 String historyName, int type, WorkSource newWs, int newPid, String newName, 471 String newHistoryName, int newType, boolean newUnimportantForLogging) { 472 enforceCallingPermission(); 473 synchronized (mStats) { 474 mStats.noteChangeWakelockFromSourceLocked(ws, pid, name, historyName, type, 475 newWs, newPid, newName, newHistoryName, newType, newUnimportantForLogging); 476 } 477 } 478 479 public void noteStopWakelockFromSource(WorkSource ws, int pid, String name, String historyName, 480 int type) { 481 enforceCallingPermission(); 482 synchronized (mStats) { 483 mStats.noteStopWakeFromSourceLocked(ws, pid, name, historyName, type); 484 } 485 } 486 487 public void noteStartSensor(int uid, int sensor) { 488 enforceCallingPermission(); 489 synchronized (mStats) { 490 mStats.noteStartSensorLocked(uid, sensor); 491 } 492 } 493 494 public void noteStopSensor(int uid, int sensor) { 495 enforceCallingPermission(); 496 synchronized (mStats) { 497 mStats.noteStopSensorLocked(uid, sensor); 498 } 499 } 500 501 public void noteVibratorOn(int uid, long durationMillis) { 502 enforceCallingPermission(); 503 synchronized (mStats) { 504 mStats.noteVibratorOnLocked(uid, durationMillis); 505 } 506 } 507 508 public void noteVibratorOff(int uid) { 509 enforceCallingPermission(); 510 synchronized (mStats) { 511 mStats.noteVibratorOffLocked(uid); 512 } 513 } 514 515 public void noteStartGps(int uid) { 516 enforceCallingPermission(); 517 synchronized (mStats) { 518 mStats.noteStartGpsLocked(uid); 519 } 520 } 521 522 public void noteStopGps(int uid) { 523 enforceCallingPermission(); 524 synchronized (mStats) { 525 mStats.noteStopGpsLocked(uid); 526 } 527 } 528 529 public void noteScreenState(int state) { 530 enforceCallingPermission(); 531 synchronized (mStats) { 532 mStats.noteScreenStateLocked(state); 533 } 534 } 535 536 public void noteScreenBrightness(int brightness) { 537 enforceCallingPermission(); 538 synchronized (mStats) { 539 mStats.noteScreenBrightnessLocked(brightness); 540 } 541 } 542 543 public void noteUserActivity(int uid, int event) { 544 enforceCallingPermission(); 545 synchronized (mStats) { 546 mStats.noteUserActivityLocked(uid, event); 547 } 548 } 549 550 public void noteWakeUp(String reason, int reasonUid) { 551 enforceCallingPermission(); 552 synchronized (mStats) { 553 mStats.noteWakeUpLocked(reason, reasonUid); 554 } 555 } 556 557 public void noteInteractive(boolean interactive) { 558 enforceCallingPermission(); 559 synchronized (mStats) { 560 mStats.noteInteractiveLocked(interactive); 561 } 562 } 563 564 public void noteConnectivityChanged(int type, String extra) { 565 enforceCallingPermission(); 566 synchronized (mStats) { 567 mStats.noteConnectivityChangedLocked(type, extra); 568 } 569 } 570 571 public void noteMobileRadioPowerState(int powerState, long timestampNs, int uid) { 572 enforceCallingPermission(); 573 synchronized (mStats) { 574 mStats.noteMobileRadioPowerState(powerState, timestampNs, uid); 575 } 576 } 577 578 public void notePhoneOn() { 579 enforceCallingPermission(); 580 synchronized (mStats) { 581 mStats.notePhoneOnLocked(); 582 } 583 } 584 585 public void notePhoneOff() { 586 enforceCallingPermission(); 587 synchronized (mStats) { 588 mStats.notePhoneOffLocked(); 589 } 590 } 591 592 public void notePhoneSignalStrength(SignalStrength signalStrength) { 593 enforceCallingPermission(); 594 synchronized (mStats) { 595 mStats.notePhoneSignalStrengthLocked(signalStrength); 596 } 597 } 598 599 public void notePhoneDataConnectionState(int dataType, boolean hasData) { 600 enforceCallingPermission(); 601 synchronized (mStats) { 602 mStats.notePhoneDataConnectionStateLocked(dataType, hasData); 603 } 604 } 605 606 public void notePhoneState(int state) { 607 enforceCallingPermission(); 608 int simState = TelephonyManager.getDefault().getSimState(); 609 synchronized (mStats) { 610 mStats.notePhoneStateLocked(state, simState); 611 } 612 } 613 614 public void noteWifiOn() { 615 enforceCallingPermission(); 616 synchronized (mStats) { 617 mStats.noteWifiOnLocked(); 618 } 619 } 620 621 public void noteWifiOff() { 622 enforceCallingPermission(); 623 synchronized (mStats) { 624 mStats.noteWifiOffLocked(); 625 } 626 } 627 628 public void noteStartAudio(int uid) { 629 enforceCallingPermission(); 630 synchronized (mStats) { 631 mStats.noteAudioOnLocked(uid); 632 } 633 } 634 635 public void noteStopAudio(int uid) { 636 enforceCallingPermission(); 637 synchronized (mStats) { 638 mStats.noteAudioOffLocked(uid); 639 } 640 } 641 642 public void noteStartVideo(int uid) { 643 enforceCallingPermission(); 644 synchronized (mStats) { 645 mStats.noteVideoOnLocked(uid); 646 } 647 } 648 649 public void noteStopVideo(int uid) { 650 enforceCallingPermission(); 651 synchronized (mStats) { 652 mStats.noteVideoOffLocked(uid); 653 } 654 } 655 656 public void noteResetAudio() { 657 enforceCallingPermission(); 658 synchronized (mStats) { 659 mStats.noteResetAudioLocked(); 660 } 661 } 662 663 public void noteResetVideo() { 664 enforceCallingPermission(); 665 synchronized (mStats) { 666 mStats.noteResetVideoLocked(); 667 } 668 } 669 670 public void noteFlashlightOn(int uid) { 671 enforceCallingPermission(); 672 synchronized (mStats) { 673 mStats.noteFlashlightOnLocked(uid); 674 } 675 } 676 677 public void noteFlashlightOff(int uid) { 678 enforceCallingPermission(); 679 synchronized (mStats) { 680 mStats.noteFlashlightOffLocked(uid); 681 } 682 } 683 684 public void noteStartCamera(int uid) { 685 enforceCallingPermission(); 686 synchronized (mStats) { 687 mStats.noteCameraOnLocked(uid); 688 } 689 } 690 691 public void noteStopCamera(int uid) { 692 enforceCallingPermission(); 693 synchronized (mStats) { 694 mStats.noteCameraOffLocked(uid); 695 } 696 } 697 698 public void noteResetCamera() { 699 enforceCallingPermission(); 700 synchronized (mStats) { 701 mStats.noteResetCameraLocked(); 702 } 703 } 704 705 public void noteResetFlashlight() { 706 enforceCallingPermission(); 707 synchronized (mStats) { 708 mStats.noteResetFlashlightLocked(); 709 } 710 } 711 712 @Override 713 public void noteWifiRadioPowerState(int powerState, long tsNanos) { 714 enforceCallingPermission(); 715 716 // There was a change in WiFi power state. 717 // Collect data now for the past activity. 718 synchronized (mStats) { 719 if (mStats.isOnBattery()) { 720 final String type = (powerState == DataConnectionRealTimeInfo.DC_POWER_STATE_HIGH || 721 powerState == DataConnectionRealTimeInfo.DC_POWER_STATE_MEDIUM) ? "active" 722 : "inactive"; 723 mHandler.scheduleSync("wifi-data: " + type, 724 BatteryStatsImpl.ExternalStatsSync.UPDATE_WIFI); 725 } 726 mStats.noteWifiRadioPowerState(powerState, tsNanos); 727 } 728 } 729 730 public void noteWifiRunning(WorkSource ws) { 731 enforceCallingPermission(); 732 synchronized (mStats) { 733 mStats.noteWifiRunningLocked(ws); 734 } 735 } 736 737 public void noteWifiRunningChanged(WorkSource oldWs, WorkSource newWs) { 738 enforceCallingPermission(); 739 synchronized (mStats) { 740 mStats.noteWifiRunningChangedLocked(oldWs, newWs); 741 } 742 } 743 744 public void noteWifiStopped(WorkSource ws) { 745 enforceCallingPermission(); 746 synchronized (mStats) { 747 mStats.noteWifiStoppedLocked(ws); 748 } 749 } 750 751 public void noteWifiState(int wifiState, String accessPoint) { 752 enforceCallingPermission(); 753 synchronized (mStats) { 754 mStats.noteWifiStateLocked(wifiState, accessPoint); 755 } 756 } 757 758 public void noteWifiSupplicantStateChanged(int supplState, boolean failedAuth) { 759 enforceCallingPermission(); 760 synchronized (mStats) { 761 mStats.noteWifiSupplicantStateChangedLocked(supplState, failedAuth); 762 } 763 } 764 765 public void noteWifiRssiChanged(int newRssi) { 766 enforceCallingPermission(); 767 synchronized (mStats) { 768 mStats.noteWifiRssiChangedLocked(newRssi); 769 } 770 } 771 772 public void noteFullWifiLockAcquired(int uid) { 773 enforceCallingPermission(); 774 synchronized (mStats) { 775 mStats.noteFullWifiLockAcquiredLocked(uid); 776 } 777 } 778 779 public void noteFullWifiLockReleased(int uid) { 780 enforceCallingPermission(); 781 synchronized (mStats) { 782 mStats.noteFullWifiLockReleasedLocked(uid); 783 } 784 } 785 786 public void noteWifiScanStarted(int uid) { 787 enforceCallingPermission(); 788 synchronized (mStats) { 789 mStats.noteWifiScanStartedLocked(uid); 790 } 791 } 792 793 public void noteWifiScanStopped(int uid) { 794 enforceCallingPermission(); 795 synchronized (mStats) { 796 mStats.noteWifiScanStoppedLocked(uid); 797 } 798 } 799 800 public void noteWifiMulticastEnabled(int uid) { 801 enforceCallingPermission(); 802 synchronized (mStats) { 803 mStats.noteWifiMulticastEnabledLocked(uid); 804 } 805 } 806 807 public void noteWifiMulticastDisabled(int uid) { 808 enforceCallingPermission(); 809 synchronized (mStats) { 810 mStats.noteWifiMulticastDisabledLocked(uid); 811 } 812 } 813 814 public void noteFullWifiLockAcquiredFromSource(WorkSource ws) { 815 enforceCallingPermission(); 816 synchronized (mStats) { 817 mStats.noteFullWifiLockAcquiredFromSourceLocked(ws); 818 } 819 } 820 821 public void noteFullWifiLockReleasedFromSource(WorkSource ws) { 822 enforceCallingPermission(); 823 synchronized (mStats) { 824 mStats.noteFullWifiLockReleasedFromSourceLocked(ws); 825 } 826 } 827 828 public void noteWifiScanStartedFromSource(WorkSource ws) { 829 enforceCallingPermission(); 830 synchronized (mStats) { 831 mStats.noteWifiScanStartedFromSourceLocked(ws); 832 } 833 } 834 835 public void noteWifiScanStoppedFromSource(WorkSource ws) { 836 enforceCallingPermission(); 837 synchronized (mStats) { 838 mStats.noteWifiScanStoppedFromSourceLocked(ws); 839 } 840 } 841 842 public void noteWifiBatchedScanStartedFromSource(WorkSource ws, int csph) { 843 enforceCallingPermission(); 844 synchronized (mStats) { 845 mStats.noteWifiBatchedScanStartedFromSourceLocked(ws, csph); 846 } 847 } 848 849 public void noteWifiBatchedScanStoppedFromSource(WorkSource ws) { 850 enforceCallingPermission(); 851 synchronized (mStats) { 852 mStats.noteWifiBatchedScanStoppedFromSourceLocked(ws); 853 } 854 } 855 856 public void noteWifiMulticastEnabledFromSource(WorkSource ws) { 857 enforceCallingPermission(); 858 synchronized (mStats) { 859 mStats.noteWifiMulticastEnabledFromSourceLocked(ws); 860 } 861 } 862 863 @Override 864 public void noteWifiMulticastDisabledFromSource(WorkSource ws) { 865 enforceCallingPermission(); 866 synchronized (mStats) { 867 mStats.noteWifiMulticastDisabledFromSourceLocked(ws); 868 } 869 } 870 871 @Override 872 public void noteNetworkInterfaceType(String iface, int networkType) { 873 enforceCallingPermission(); 874 synchronized (mStats) { 875 mStats.noteNetworkInterfaceTypeLocked(iface, networkType); 876 } 877 } 878 879 @Override 880 public void noteNetworkStatsEnabled() { 881 enforceCallingPermission(); 882 synchronized (mStats) { 883 mStats.noteNetworkStatsEnabledLocked(); 884 } 885 } 886 887 @Override 888 public void noteDeviceIdleMode(int mode, String activeReason, int activeUid) { 889 enforceCallingPermission(); 890 synchronized (mStats) { 891 mStats.noteDeviceIdleModeLocked(mode, activeReason, activeUid); 892 } 893 } 894 895 public void notePackageInstalled(String pkgName, int versionCode) { 896 enforceCallingPermission(); 897 synchronized (mStats) { 898 mStats.notePackageInstalledLocked(pkgName, versionCode); 899 } 900 } 901 902 public void notePackageUninstalled(String pkgName) { 903 enforceCallingPermission(); 904 synchronized (mStats) { 905 mStats.notePackageUninstalledLocked(pkgName); 906 } 907 } 908 909 @Override 910 public void noteBleScanStarted(WorkSource ws) { 911 enforceCallingPermission(); 912 synchronized (mStats) { 913 mStats.noteBluetoothScanStartedFromSourceLocked(ws); 914 } 915 } 916 917 @Override 918 public void noteBleScanStopped(WorkSource ws) { 919 enforceCallingPermission(); 920 synchronized (mStats) { 921 mStats.noteBluetoothScanStoppedFromSourceLocked(ws); 922 } 923 } 924 925 @Override 926 public void noteResetBleScan() { 927 enforceCallingPermission(); 928 synchronized (mStats) { 929 mStats.noteResetBluetoothScanLocked(); 930 } 931 } 932 933 @Override 934 public void noteWifiControllerActivity(WifiActivityEnergyInfo info) { 935 enforceCallingPermission(); 936 937 if (info == null || !info.isValid()) { 938 Slog.e(TAG, "invalid wifi data given: " + info); 939 return; 940 } 941 942 synchronized (mStats) { 943 mStats.updateWifiStateLocked(info); 944 } 945 } 946 947 @Override 948 public void noteBluetoothControllerActivity(BluetoothActivityEnergyInfo info) { 949 enforceCallingPermission(); 950 if (info == null || !info.isValid()) { 951 Slog.e(TAG, "invalid bluetooth data given: " + info); 952 return; 953 } 954 955 synchronized (mStats) { 956 mStats.updateBluetoothStateLocked(info); 957 } 958 } 959 960 @Override 961 public void noteModemControllerActivity(ModemActivityInfo info) { 962 enforceCallingPermission(); 963 964 if (info == null || !info.isValid()) { 965 Slog.e(TAG, "invalid modem data given: " + info); 966 return; 967 } 968 969 synchronized (mStats) { 970 mStats.updateMobileRadioStateLocked(SystemClock.elapsedRealtime(), info); 971 } 972 } 973 974 public boolean isOnBattery() { 975 return mStats.isOnBattery(); 976 } 977 978 @Override 979 public void setBatteryState(final int status, final int health, final int plugType, 980 final int level, final int temp, final int volt, final int chargeUAh) { 981 enforceCallingPermission(); 982 983 // BatteryService calls us here and we may update external state. It would be wrong 984 // to block such a low level service like BatteryService on external stats like WiFi. 985 mHandler.post(new Runnable() { 986 @Override 987 public void run() { 988 synchronized (mStats) { 989 final boolean onBattery = plugType == BatteryStatsImpl.BATTERY_PLUGGED_NONE; 990 if (mStats.isOnBattery() == onBattery) { 991 // The battery state has not changed, so we don't need to sync external 992 // stats immediately. 993 mStats.setBatteryStateLocked(status, health, plugType, level, temp, volt, 994 chargeUAh); 995 return; 996 } 997 } 998 999 // Sync external stats first as the battery has changed states. If we don't sync 1000 // immediately here, we may not collect the relevant data later. 1001 updateExternalStatsSync("battery-state", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1002 synchronized (mStats) { 1003 mStats.setBatteryStateLocked(status, health, plugType, level, temp, volt, 1004 chargeUAh); 1005 } 1006 } 1007 }); 1008 } 1009 1010 public long getAwakeTimeBattery() { 1011 mContext.enforceCallingOrSelfPermission( 1012 android.Manifest.permission.BATTERY_STATS, null); 1013 return mStats.getAwakeTimeBattery(); 1014 } 1015 1016 public long getAwakeTimePlugged() { 1017 mContext.enforceCallingOrSelfPermission( 1018 android.Manifest.permission.BATTERY_STATS, null); 1019 return mStats.getAwakeTimePlugged(); 1020 } 1021 1022 public void enforceCallingPermission() { 1023 if (Binder.getCallingPid() == Process.myPid()) { 1024 return; 1025 } 1026 mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, 1027 Binder.getCallingPid(), Binder.getCallingUid(), null); 1028 } 1029 1030 final class WakeupReasonThread extends Thread { 1031 private static final int MAX_REASON_SIZE = 512; 1032 private CharsetDecoder mDecoder; 1033 private ByteBuffer mUtf8Buffer; 1034 private CharBuffer mUtf16Buffer; 1035 1036 WakeupReasonThread() { 1037 super("BatteryStats_wakeupReason"); 1038 } 1039 1040 public void run() { 1041 Process.setThreadPriority(Process.THREAD_PRIORITY_FOREGROUND); 1042 1043 mDecoder = StandardCharsets.UTF_8 1044 .newDecoder() 1045 .onMalformedInput(CodingErrorAction.REPLACE) 1046 .onUnmappableCharacter(CodingErrorAction.REPLACE) 1047 .replaceWith("?"); 1048 1049 mUtf8Buffer = ByteBuffer.allocateDirect(MAX_REASON_SIZE); 1050 mUtf16Buffer = CharBuffer.allocate(MAX_REASON_SIZE); 1051 1052 try { 1053 String reason; 1054 while ((reason = waitWakeup()) != null) { 1055 synchronized (mStats) { 1056 mStats.noteWakeupReasonLocked(reason); 1057 } 1058 } 1059 } catch (RuntimeException e) { 1060 Slog.e(TAG, "Failure reading wakeup reasons", e); 1061 } 1062 } 1063 1064 private String waitWakeup() { 1065 mUtf8Buffer.clear(); 1066 mUtf16Buffer.clear(); 1067 mDecoder.reset(); 1068 1069 int bytesWritten = nativeWaitWakeup(mUtf8Buffer); 1070 if (bytesWritten < 0) { 1071 return null; 1072 } else if (bytesWritten == 0) { 1073 return "unknown"; 1074 } 1075 1076 // Set the buffer's limit to the number of bytes written. 1077 mUtf8Buffer.limit(bytesWritten); 1078 1079 // Decode the buffer from UTF-8 to UTF-16. 1080 // Unmappable characters will be replaced. 1081 mDecoder.decode(mUtf8Buffer, mUtf16Buffer, true); 1082 mUtf16Buffer.flip(); 1083 1084 // Create a String from the UTF-16 buffer. 1085 return mUtf16Buffer.toString(); 1086 } 1087 } 1088 1089 private static native int nativeWaitWakeup(ByteBuffer outBuffer); 1090 1091 private void dumpHelp(PrintWriter pw) { 1092 pw.println("Battery stats (batterystats) dump options:"); 1093 pw.println(" [--checkin] [--history] [--history-start] [--charged] [-c]"); 1094 pw.println(" [--daily] [--reset] [--write] [--new-daily] [--read-daily] [-h] [<package.name>]"); 1095 pw.println(" --checkin: generate output for a checkin report; will write (and clear) the"); 1096 pw.println(" last old completed stats when they had been reset."); 1097 pw.println(" -c: write the current stats in checkin format."); 1098 pw.println(" --history: show only history data."); 1099 pw.println(" --history-start <num>: show only history data starting at given time offset."); 1100 pw.println(" --charged: only output data since last charged."); 1101 pw.println(" --daily: only output full daily data."); 1102 pw.println(" --reset: reset the stats, clearing all current data."); 1103 pw.println(" --write: force write current collected stats to disk."); 1104 pw.println(" --new-daily: immediately create and write new daily stats record."); 1105 pw.println(" --read-daily: read-load last written daily stats."); 1106 pw.println(" <package.name>: optional name of package to filter output by."); 1107 pw.println(" -h: print this help text."); 1108 pw.println("Battery stats (batterystats) commands:"); 1109 pw.println(" enable|disable <option>"); 1110 pw.println(" Enable or disable a running option. Option state is not saved across boots."); 1111 pw.println(" Options are:"); 1112 pw.println(" full-history: include additional detailed events in battery history:"); 1113 pw.println(" wake_lock_in, alarms and proc events"); 1114 pw.println(" no-auto-reset: don't automatically reset stats when unplugged"); 1115 } 1116 1117 private int doEnableOrDisable(PrintWriter pw, int i, String[] args, boolean enable) { 1118 i++; 1119 if (i >= args.length) { 1120 pw.println("Missing option argument for " + (enable ? "--enable" : "--disable")); 1121 dumpHelp(pw); 1122 return -1; 1123 } 1124 if ("full-wake-history".equals(args[i]) || "full-history".equals(args[i])) { 1125 synchronized (mStats) { 1126 mStats.setRecordAllHistoryLocked(enable); 1127 } 1128 } else if ("no-auto-reset".equals(args[i])) { 1129 synchronized (mStats) { 1130 mStats.setNoAutoReset(enable); 1131 } 1132 } else { 1133 pw.println("Unknown enable/disable option: " + args[i]); 1134 dumpHelp(pw); 1135 return -1; 1136 } 1137 return i; 1138 } 1139 1140 1141 @Override 1142 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 1143 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) 1144 != PackageManager.PERMISSION_GRANTED) { 1145 pw.println("Permission Denial: can't dump BatteryStats from from pid=" 1146 + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() 1147 + " without permission " + android.Manifest.permission.DUMP); 1148 return; 1149 } 1150 1151 int flags = 0; 1152 boolean useCheckinFormat = false; 1153 boolean isRealCheckin = false; 1154 boolean noOutput = false; 1155 boolean writeData = false; 1156 long historyStart = -1; 1157 int reqUid = -1; 1158 if (args != null) { 1159 for (int i=0; i<args.length; i++) { 1160 String arg = args[i]; 1161 if ("--checkin".equals(arg)) { 1162 useCheckinFormat = true; 1163 isRealCheckin = true; 1164 } else if ("--history".equals(arg)) { 1165 flags |= BatteryStats.DUMP_HISTORY_ONLY; 1166 } else if ("--history-start".equals(arg)) { 1167 flags |= BatteryStats.DUMP_HISTORY_ONLY; 1168 i++; 1169 if (i >= args.length) { 1170 pw.println("Missing time argument for --history-since"); 1171 dumpHelp(pw); 1172 return; 1173 } 1174 historyStart = Long.parseLong(args[i]); 1175 writeData = true; 1176 } else if ("-c".equals(arg)) { 1177 useCheckinFormat = true; 1178 flags |= BatteryStats.DUMP_INCLUDE_HISTORY; 1179 } else if ("--charged".equals(arg)) { 1180 flags |= BatteryStats.DUMP_CHARGED_ONLY; 1181 } else if ("--daily".equals(arg)) { 1182 flags |= BatteryStats.DUMP_DAILY_ONLY; 1183 } else if ("--reset".equals(arg)) { 1184 synchronized (mStats) { 1185 mStats.resetAllStatsCmdLocked(); 1186 pw.println("Battery stats reset."); 1187 noOutput = true; 1188 } 1189 updateExternalStatsSync("dump", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1190 } else if ("--write".equals(arg)) { 1191 updateExternalStatsSync("dump", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1192 synchronized (mStats) { 1193 mStats.writeSyncLocked(); 1194 pw.println("Battery stats written."); 1195 noOutput = true; 1196 } 1197 } else if ("--new-daily".equals(arg)) { 1198 synchronized (mStats) { 1199 mStats.recordDailyStatsLocked(); 1200 pw.println("New daily stats written."); 1201 noOutput = true; 1202 } 1203 } else if ("--read-daily".equals(arg)) { 1204 synchronized (mStats) { 1205 mStats.readDailyStatsLocked(); 1206 pw.println("Last daily stats read."); 1207 noOutput = true; 1208 } 1209 } else if ("--enable".equals(arg) || "enable".equals(arg)) { 1210 i = doEnableOrDisable(pw, i, args, true); 1211 if (i < 0) { 1212 return; 1213 } 1214 pw.println("Enabled: " + args[i]); 1215 return; 1216 } else if ("--disable".equals(arg) || "disable".equals(arg)) { 1217 i = doEnableOrDisable(pw, i, args, false); 1218 if (i < 0) { 1219 return; 1220 } 1221 pw.println("Disabled: " + args[i]); 1222 return; 1223 } else if ("-h".equals(arg)) { 1224 dumpHelp(pw); 1225 return; 1226 } else if ("-a".equals(arg)) { 1227 flags |= BatteryStats.DUMP_VERBOSE; 1228 } else if (arg.length() > 0 && arg.charAt(0) == '-'){ 1229 pw.println("Unknown option: " + arg); 1230 dumpHelp(pw); 1231 return; 1232 } else { 1233 // Not an option, last argument must be a package name. 1234 try { 1235 reqUid = mContext.getPackageManager().getPackageUidAsUser(arg, 1236 UserHandle.getCallingUserId()); 1237 } catch (PackageManager.NameNotFoundException e) { 1238 pw.println("Unknown package: " + arg); 1239 dumpHelp(pw); 1240 return; 1241 } 1242 } 1243 } 1244 } 1245 if (noOutput) { 1246 return; 1247 } 1248 1249 long ident = Binder.clearCallingIdentity(); 1250 try { 1251 if (BatteryStatsHelper.checkWifiOnly(mContext)) { 1252 flags |= BatteryStats.DUMP_DEVICE_WIFI_ONLY; 1253 } 1254 // Fetch data from external sources and update the BatteryStatsImpl object with them. 1255 updateExternalStatsSync("dump", BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1256 } finally { 1257 Binder.restoreCallingIdentity(ident); 1258 } 1259 1260 if (reqUid >= 0) { 1261 // By default, if the caller is only interested in a specific package, then 1262 // we only dump the aggregated data since charged. 1263 if ((flags&(BatteryStats.DUMP_HISTORY_ONLY|BatteryStats.DUMP_CHARGED_ONLY)) == 0) { 1264 flags |= BatteryStats.DUMP_CHARGED_ONLY; 1265 // Also if they are doing -c, we don't want history. 1266 flags &= ~BatteryStats.DUMP_INCLUDE_HISTORY; 1267 } 1268 } 1269 1270 if (useCheckinFormat) { 1271 List<ApplicationInfo> apps = mContext.getPackageManager().getInstalledApplications( 1272 PackageManager.MATCH_UNINSTALLED_PACKAGES | PackageManager.MATCH_ALL); 1273 if (isRealCheckin) { 1274 // For a real checkin, first we want to prefer to use the last complete checkin 1275 // file if there is one. 1276 synchronized (mStats.mCheckinFile) { 1277 if (mStats.mCheckinFile.exists()) { 1278 try { 1279 byte[] raw = mStats.mCheckinFile.readFully(); 1280 if (raw != null) { 1281 Parcel in = Parcel.obtain(); 1282 in.unmarshall(raw, 0, raw.length); 1283 in.setDataPosition(0); 1284 BatteryStatsImpl checkinStats = new BatteryStatsImpl( 1285 null, mStats.mHandler, null); 1286 checkinStats.readSummaryFromParcel(in); 1287 in.recycle(); 1288 checkinStats.dumpCheckinLocked(mContext, pw, apps, flags, 1289 historyStart); 1290 mStats.mCheckinFile.delete(); 1291 return; 1292 } 1293 } catch (IOException | ParcelFormatException e) { 1294 Slog.w(TAG, "Failure reading checkin file " 1295 + mStats.mCheckinFile.getBaseFile(), e); 1296 } 1297 } 1298 } 1299 } 1300 synchronized (mStats) { 1301 mStats.dumpCheckinLocked(mContext, pw, apps, flags, historyStart); 1302 if (writeData) { 1303 mStats.writeAsyncLocked(); 1304 } 1305 } 1306 } else { 1307 synchronized (mStats) { 1308 mStats.dumpLocked(mContext, pw, flags, reqUid, historyStart); 1309 if (writeData) { 1310 mStats.writeAsyncLocked(); 1311 } 1312 } 1313 } 1314 } 1315 1316 private WifiActivityEnergyInfo extractDelta(WifiActivityEnergyInfo latest) { 1317 final long timePeriodMs = latest.mTimestamp - mLastInfo.mTimestamp; 1318 final long lastIdleMs = mLastInfo.mControllerIdleTimeMs; 1319 final long lastTxMs = mLastInfo.mControllerTxTimeMs; 1320 final long lastRxMs = mLastInfo.mControllerRxTimeMs; 1321 final long lastEnergy = mLastInfo.mControllerEnergyUsed; 1322 1323 // We will modify the last info object to be the delta, and store the new 1324 // WifiActivityEnergyInfo object as our last one. 1325 final WifiActivityEnergyInfo delta = mLastInfo; 1326 delta.mTimestamp = latest.getTimeStamp(); 1327 delta.mStackState = latest.getStackState(); 1328 1329 final long txTimeMs = latest.mControllerTxTimeMs - lastTxMs; 1330 final long rxTimeMs = latest.mControllerRxTimeMs - lastRxMs; 1331 final long idleTimeMs = latest.mControllerIdleTimeMs - lastIdleMs; 1332 1333 if (txTimeMs < 0 || rxTimeMs < 0) { 1334 // The stats were reset by the WiFi system (which is why our delta is negative). 1335 // Returns the unaltered stats. 1336 delta.mControllerEnergyUsed = latest.mControllerEnergyUsed; 1337 delta.mControllerRxTimeMs = latest.mControllerRxTimeMs; 1338 delta.mControllerTxTimeMs = latest.mControllerTxTimeMs; 1339 delta.mControllerIdleTimeMs = latest.mControllerIdleTimeMs; 1340 Slog.v(TAG, "WiFi energy data was reset, new WiFi energy data is " + delta); 1341 } else { 1342 final long totalActiveTimeMs = txTimeMs + rxTimeMs; 1343 long maxExpectedIdleTimeMs; 1344 if (totalActiveTimeMs > timePeriodMs) { 1345 // Cap the max idle time at zero since the active time consumed the whole time 1346 maxExpectedIdleTimeMs = 0; 1347 if (totalActiveTimeMs > timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) { 1348 StringBuilder sb = new StringBuilder(); 1349 sb.append("Total Active time "); 1350 TimeUtils.formatDuration(totalActiveTimeMs, sb); 1351 sb.append(" is longer than sample period "); 1352 TimeUtils.formatDuration(timePeriodMs, sb); 1353 sb.append(".\n"); 1354 sb.append("Previous WiFi snapshot: ").append("idle="); 1355 TimeUtils.formatDuration(lastIdleMs, sb); 1356 sb.append(" rx="); 1357 TimeUtils.formatDuration(lastRxMs, sb); 1358 sb.append(" tx="); 1359 TimeUtils.formatDuration(lastTxMs, sb); 1360 sb.append(" e=").append(lastEnergy); 1361 sb.append("\n"); 1362 sb.append("Current WiFi snapshot: ").append("idle="); 1363 TimeUtils.formatDuration(latest.mControllerIdleTimeMs, sb); 1364 sb.append(" rx="); 1365 TimeUtils.formatDuration(latest.mControllerRxTimeMs, sb); 1366 sb.append(" tx="); 1367 TimeUtils.formatDuration(latest.mControllerTxTimeMs, sb); 1368 sb.append(" e=").append(latest.mControllerEnergyUsed); 1369 Slog.wtf(TAG, sb.toString()); 1370 } 1371 } else { 1372 maxExpectedIdleTimeMs = timePeriodMs - totalActiveTimeMs; 1373 } 1374 // These times seem to be the most reliable. 1375 delta.mControllerTxTimeMs = txTimeMs; 1376 delta.mControllerRxTimeMs = rxTimeMs; 1377 // WiFi calculates the idle time as a difference from the on time and the various 1378 // Rx + Tx times. There seems to be some missing time there because this sometimes 1379 // becomes negative. Just cap it at 0 and ensure that it is less than the expected idle 1380 // time from the difference in timestamps. 1381 // b/21613534 1382 delta.mControllerIdleTimeMs = Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs)); 1383 delta.mControllerEnergyUsed = Math.max(0, latest.mControllerEnergyUsed - lastEnergy); 1384 } 1385 1386 mLastInfo = latest; 1387 return delta; 1388 } 1389 1390 /** 1391 * Helper method to extract the Parcelable controller info from a 1392 * SynchronousResultReceiver. 1393 */ 1394 private static <T extends Parcelable> T awaitControllerInfo( 1395 @Nullable SynchronousResultReceiver receiver) throws TimeoutException { 1396 if (receiver == null) { 1397 return null; 1398 } 1399 1400 final SynchronousResultReceiver.Result result = 1401 receiver.awaitResult(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS); 1402 if (result.bundle != null) { 1403 // This is the final destination for the Bundle. 1404 result.bundle.setDefusable(true); 1405 1406 final T data = result.bundle.getParcelable(BatteryStats.RESULT_RECEIVER_CONTROLLER_KEY); 1407 if (data != null) { 1408 return data; 1409 } 1410 } 1411 Slog.e(TAG, "no controller energy info supplied"); 1412 return null; 1413 } 1414 1415 /** 1416 * Fetches data from external sources (WiFi controller, bluetooth chipset) and updates 1417 * batterystats with that information. 1418 * 1419 * We first grab a lock specific to this method, then once all the data has been collected, 1420 * we grab the mStats lock and update the data. 1421 * 1422 * @param reason The reason why this collection was requested. Useful for debugging. 1423 * @param updateFlags Which external stats to update. Can be a combination of 1424 * {@link BatteryStatsImpl.ExternalStatsSync#UPDATE_CPU}, 1425 * {@link BatteryStatsImpl.ExternalStatsSync#UPDATE_RADIO}, 1426 * {@link BatteryStatsImpl.ExternalStatsSync#UPDATE_WIFI}, 1427 * and {@link BatteryStatsImpl.ExternalStatsSync#UPDATE_BT}. 1428 */ 1429 void updateExternalStatsSync(final String reason, int updateFlags) { 1430 SynchronousResultReceiver wifiReceiver = null; 1431 SynchronousResultReceiver bluetoothReceiver = null; 1432 SynchronousResultReceiver modemReceiver = null; 1433 1434 synchronized (mExternalStatsLock) { 1435 if (mContext == null) { 1436 // Don't do any work yet. 1437 return; 1438 } 1439 1440 if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_WIFI) != 0) { 1441 if (mWifiManager == null) { 1442 mWifiManager = IWifiManager.Stub.asInterface( 1443 ServiceManager.getService(Context.WIFI_SERVICE)); 1444 } 1445 1446 if (mWifiManager != null) { 1447 try { 1448 wifiReceiver = new SynchronousResultReceiver(); 1449 mWifiManager.requestActivityInfo(wifiReceiver); 1450 } catch (RemoteException e) { 1451 // Oh well. 1452 } 1453 } 1454 } 1455 1456 if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_BT) != 0) { 1457 final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 1458 if (adapter != null) { 1459 bluetoothReceiver = new SynchronousResultReceiver(); 1460 adapter.requestControllerActivityEnergyInfo(bluetoothReceiver); 1461 } 1462 } 1463 1464 if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO) != 0) { 1465 if (mTelephony == null) { 1466 mTelephony = TelephonyManager.from(mContext); 1467 } 1468 1469 if (mTelephony != null) { 1470 modemReceiver = new SynchronousResultReceiver(); 1471 mTelephony.requestModemActivityInfo(modemReceiver); 1472 } 1473 } 1474 1475 WifiActivityEnergyInfo wifiInfo = null; 1476 BluetoothActivityEnergyInfo bluetoothInfo = null; 1477 ModemActivityInfo modemInfo = null; 1478 try { 1479 wifiInfo = awaitControllerInfo(wifiReceiver); 1480 } catch (TimeoutException e) { 1481 Slog.w(TAG, "Timeout reading wifi stats"); 1482 } 1483 1484 try { 1485 bluetoothInfo = awaitControllerInfo(bluetoothReceiver); 1486 } catch (TimeoutException e) { 1487 Slog.w(TAG, "Timeout reading bt stats"); 1488 } 1489 1490 try { 1491 modemInfo = awaitControllerInfo(modemReceiver); 1492 } catch (TimeoutException e) { 1493 Slog.w(TAG, "Timeout reading modem stats"); 1494 } 1495 1496 synchronized (mStats) { 1497 mStats.addHistoryEventLocked( 1498 SystemClock.elapsedRealtime(), 1499 SystemClock.uptimeMillis(), 1500 BatteryStats.HistoryItem.EVENT_COLLECT_EXTERNAL_STATS, 1501 reason, 0); 1502 1503 mStats.updateCpuTimeLocked(); 1504 mStats.updateKernelWakelocksLocked(); 1505 1506 if (wifiInfo != null) { 1507 if (wifiInfo.isValid()) { 1508 mStats.updateWifiStateLocked(extractDelta(wifiInfo)); 1509 } else { 1510 Slog.e(TAG, "wifi info is invalid: " + wifiInfo); 1511 } 1512 } 1513 1514 if (bluetoothInfo != null) { 1515 if (bluetoothInfo.isValid()) { 1516 mStats.updateBluetoothStateLocked(bluetoothInfo); 1517 } else { 1518 Slog.e(TAG, "bluetooth info is invalid: " + bluetoothInfo); 1519 } 1520 } 1521 1522 if (modemInfo != null) { 1523 if (modemInfo.isValid()) { 1524 mStats.updateMobileRadioStateLocked(SystemClock.elapsedRealtime(), 1525 modemInfo); 1526 } else { 1527 Slog.e(TAG, "modem info is invalid: " + modemInfo); 1528 } 1529 } 1530 } 1531 } 1532 } 1533 1534 /** 1535 * Gets a snapshot of the system health for a particular uid. 1536 */ 1537 @Override 1538 public HealthStatsParceler takeUidSnapshot(int requestUid) { 1539 if (requestUid != Binder.getCallingUid()) { 1540 mContext.enforceCallingOrSelfPermission( 1541 android.Manifest.permission.BATTERY_STATS, null); 1542 } 1543 long ident = Binder.clearCallingIdentity(); 1544 try { 1545 updateExternalStatsSync("get-health-stats-for-uid", 1546 BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1547 synchronized (mStats) { 1548 return getHealthStatsForUidLocked(requestUid); 1549 } 1550 } catch (Exception ex) { 1551 Slog.d(TAG, "Crashed while writing for takeUidSnapshot(" + requestUid + ")", ex); 1552 throw ex; 1553 } finally { 1554 Binder.restoreCallingIdentity(ident); 1555 } 1556 } 1557 1558 /** 1559 * Gets a snapshot of the system health for a number of uids. 1560 */ 1561 @Override 1562 public HealthStatsParceler[] takeUidSnapshots(int[] requestUids) { 1563 if (!onlyCaller(requestUids)) { 1564 mContext.enforceCallingOrSelfPermission( 1565 android.Manifest.permission.BATTERY_STATS, null); 1566 } 1567 long ident = Binder.clearCallingIdentity(); 1568 int i=-1; 1569 try { 1570 updateExternalStatsSync("get-health-stats-for-uids", 1571 BatteryStatsImpl.ExternalStatsSync.UPDATE_ALL); 1572 synchronized (mStats) { 1573 final int N = requestUids.length; 1574 final HealthStatsParceler[] results = new HealthStatsParceler[N]; 1575 for (i=0; i<N; i++) { 1576 results[i] = getHealthStatsForUidLocked(requestUids[i]); 1577 } 1578 return results; 1579 } 1580 } catch (Exception ex) { 1581 Slog.d(TAG, "Crashed while writing for takeUidSnapshots(" 1582 + Arrays.toString(requestUids) + ") i=" + i, ex); 1583 throw ex; 1584 } finally { 1585 Binder.restoreCallingIdentity(ident); 1586 } 1587 } 1588 1589 /** 1590 * Returns whether the Binder.getCallingUid is the only thing in requestUids. 1591 */ 1592 private static boolean onlyCaller(int[] requestUids) { 1593 final int caller = Binder.getCallingUid(); 1594 final int N = requestUids.length; 1595 for (int i=0; i<N; i++) { 1596 if (requestUids[i] != caller) { 1597 return false; 1598 } 1599 } 1600 return true; 1601 } 1602 1603 /** 1604 * Gets a HealthStatsParceler for the given uid. You should probably call 1605 * updateExternalStatsSync first. 1606 */ 1607 HealthStatsParceler getHealthStatsForUidLocked(int requestUid) { 1608 final HealthStatsBatteryStatsWriter writer = new HealthStatsBatteryStatsWriter(); 1609 final HealthStatsWriter uidWriter = new HealthStatsWriter(UidHealthStats.CONSTANTS); 1610 final BatteryStats.Uid uid = mStats.getUidStats().get(requestUid); 1611 if (uid != null) { 1612 writer.writeUid(uidWriter, mStats, uid); 1613 } 1614 return new HealthStatsParceler(uidWriter); 1615 } 1616 1617 } 1618
