1 /* 2 * Copyright (C) 2009 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 android.app.Activity; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.content.IntentFilter; 23 import android.graphics.drawable.Drawable; 24 import android.os.BatteryStats; 25 import android.os.Build; 26 import android.os.Bundle; 27 import android.os.Handler; 28 import android.os.Message; 29 import android.os.Process; 30 import android.os.SystemClock; 31 import android.os.UserHandle; 32 import android.provider.SearchIndexableResource; 33 import android.support.annotation.VisibleForTesting; 34 import android.support.v7.preference.Preference; 35 import android.support.v7.preference.PreferenceGroup; 36 import android.text.TextUtils; 37 import android.text.format.DateUtils; 38 import android.util.Log; 39 import android.util.SparseArray; 40 import android.util.TypedValue; 41 import android.view.Menu; 42 import android.view.MenuInflater; 43 import android.view.MenuItem; 44 45 import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 46 import com.android.internal.os.BatterySipper; 47 import com.android.internal.os.BatterySipper.DrainType; 48 import com.android.internal.os.PowerProfile; 49 import com.android.settings.R; 50 import com.android.settings.Settings.HighPowerApplicationsActivity; 51 import com.android.settings.SettingsActivity; 52 import com.android.settings.Utils; 53 import com.android.settings.applications.LayoutPreference; 54 import com.android.settings.applications.ManageApplications; 55 import com.android.settings.core.PreferenceController; 56 import com.android.settings.core.instrumentation.MetricsFeatureProvider; 57 import com.android.settings.dashboard.SummaryLoader; 58 import com.android.settings.display.AutoBrightnessPreferenceController; 59 import com.android.settings.display.BatteryPercentagePreferenceController; 60 import com.android.settings.display.TimeoutPreferenceController; 61 import com.android.settings.overlay.FeatureFactory; 62 import com.android.settings.search.BaseSearchIndexProvider; 63 import com.android.settings.widget.FooterPreferenceMixin; 64 import com.android.settingslib.BatteryInfo; 65 66 import java.util.ArrayList; 67 import java.util.Arrays; 68 import java.util.List; 69 70 /** 71 * Displays a list of apps and subsystems that consume power, ordered by how much power was 72 * consumed since the last time it was unplugged. 73 */ 74 public class PowerUsageSummary extends PowerUsageBase { 75 76 static final String TAG = "PowerUsageSummary"; 77 78 private static final boolean DEBUG = false; 79 private static final boolean USE_FAKE_DATA = false; 80 private static final String KEY_APP_LIST = "app_list"; 81 private static final String KEY_BATTERY_HEADER = "battery_header"; 82 private static final String KEY_SHOW_ALL_APPS = "show_all_apps"; 83 private static final int MAX_ITEMS_TO_LIST = USE_FAKE_DATA ? 30 : 10; 84 private static final int MIN_AVERAGE_POWER_THRESHOLD_MILLI_AMP = 10; 85 86 private static final String KEY_SCREEN_USAGE = "screen_usage"; 87 private static final String KEY_TIME_SINCE_LAST_FULL_CHARGE = "last_full_charge"; 88 89 private static final String KEY_AUTO_BRIGHTNESS = "auto_brightness_battery"; 90 private static final String KEY_SCREEN_TIMEOUT = "screen_timeout_battery"; 91 private static final String KEY_BATTERY_SAVER_SUMMARY = "battery_saver_summary"; 92 93 private static final int MENU_STATS_TYPE = Menu.FIRST; 94 @VisibleForTesting 95 static final int MENU_HIGH_POWER_APPS = Menu.FIRST + 3; 96 @VisibleForTesting 97 static final int MENU_ADDITIONAL_BATTERY_INFO = Menu.FIRST + 4; 98 @VisibleForTesting 99 static final int MENU_TOGGLE_APPS = Menu.FIRST + 5; 100 private static final int MENU_HELP = Menu.FIRST + 6; 101 102 private final FooterPreferenceMixin mFooterPreferenceMixin = 103 new FooterPreferenceMixin(this, getLifecycle()); 104 105 @VisibleForTesting 106 boolean mShowAllApps = false; 107 @VisibleForTesting 108 PowerGaugePreference mScreenUsagePref; 109 @VisibleForTesting 110 PowerGaugePreference mLastFullChargePref; 111 @VisibleForTesting 112 PowerUsageFeatureProvider mPowerFeatureProvider; 113 @VisibleForTesting 114 BatteryUtils mBatteryUtils; 115 116 private BatteryHeaderPreferenceController mBatteryHeaderPreferenceController; 117 private LayoutPreference mBatteryLayoutPref; 118 private PreferenceGroup mAppListGroup; 119 private int mStatsType = BatteryStats.STATS_SINCE_CHARGED; 120 121 @Override onCreate(Bundle icicle)122 public void onCreate(Bundle icicle) { 123 super.onCreate(icicle); 124 setAnimationAllowed(true); 125 126 mBatteryLayoutPref = (LayoutPreference) findPreference(KEY_BATTERY_HEADER); 127 mAppListGroup = (PreferenceGroup) findPreference(KEY_APP_LIST); 128 mScreenUsagePref = (PowerGaugePreference) findPreference(KEY_SCREEN_USAGE); 129 mLastFullChargePref = (PowerGaugePreference) findPreference( 130 KEY_TIME_SINCE_LAST_FULL_CHARGE); 131 mFooterPreferenceMixin.createFooterPreference().setTitle(R.string.battery_footer_summary); 132 133 mBatteryUtils = BatteryUtils.getInstance(getContext()); 134 135 restoreSavedInstance(icicle); 136 initFeatureProvider(); 137 } 138 139 @Override getMetricsCategory()140 public int getMetricsCategory() { 141 return MetricsEvent.FUELGAUGE_POWER_USAGE_SUMMARY; 142 } 143 144 @Override onPause()145 public void onPause() { 146 BatteryEntry.stopRequestQueue(); 147 mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON); 148 super.onPause(); 149 } 150 151 @Override onDestroy()152 public void onDestroy() { 153 super.onDestroy(); 154 if (getActivity().isChangingConfigurations()) { 155 BatteryEntry.clearUidCache(); 156 } 157 } 158 159 @Override onSaveInstanceState(Bundle outState)160 public void onSaveInstanceState(Bundle outState) { 161 super.onSaveInstanceState(outState); 162 outState.putBoolean(KEY_SHOW_ALL_APPS, mShowAllApps); 163 } 164 165 @Override onPreferenceTreeClick(Preference preference)166 public boolean onPreferenceTreeClick(Preference preference) { 167 if (KEY_BATTERY_HEADER.equals(preference.getKey())) { 168 performBatteryHeaderClick(); 169 return true; 170 } else if (!(preference instanceof PowerGaugePreference)) { 171 return super.onPreferenceTreeClick(preference); 172 } 173 PowerGaugePreference pgp = (PowerGaugePreference) preference; 174 BatteryEntry entry = pgp.getInfo(); 175 AdvancedPowerUsageDetail.startBatteryDetailPage((SettingsActivity) getActivity(), 176 this, mStatsHelper, mStatsType, entry, pgp.getPercent()); 177 return super.onPreferenceTreeClick(preference); 178 } 179 180 @Override getLogTag()181 protected String getLogTag() { 182 return TAG; 183 } 184 185 @Override getPreferenceScreenResId()186 protected int getPreferenceScreenResId() { 187 return R.xml.power_usage_summary; 188 } 189 190 @Override getPreferenceControllers(Context context)191 protected List<PreferenceController> getPreferenceControllers(Context context) { 192 final List<PreferenceController> controllers = new ArrayList<>(); 193 mBatteryHeaderPreferenceController = new BatteryHeaderPreferenceController(context); 194 controllers.add(mBatteryHeaderPreferenceController); 195 controllers.add(new AutoBrightnessPreferenceController(context, KEY_AUTO_BRIGHTNESS)); 196 controllers.add(new TimeoutPreferenceController(context, KEY_SCREEN_TIMEOUT)); 197 controllers.add(new BatterySaverController(context, getLifecycle())); 198 controllers.add(new BatteryPercentagePreferenceController(context)); 199 return controllers; 200 } 201 202 @Override onCreateOptionsMenu(Menu menu, MenuInflater inflater)203 public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { 204 if (DEBUG) { 205 menu.add(Menu.NONE, MENU_STATS_TYPE, Menu.NONE, R.string.menu_stats_total) 206 .setIcon(com.android.internal.R.drawable.ic_menu_info_details) 207 .setAlphabeticShortcut('t'); 208 } 209 210 menu.add(Menu.NONE, MENU_HIGH_POWER_APPS, Menu.NONE, R.string.high_power_apps); 211 212 if (mPowerFeatureProvider.isAdditionalBatteryInfoEnabled()) { 213 menu.add(Menu.NONE, MENU_ADDITIONAL_BATTERY_INFO, 214 Menu.NONE, R.string.additional_battery_info); 215 } 216 if (mPowerFeatureProvider.isPowerAccountingToggleEnabled()) { 217 menu.add(Menu.NONE, MENU_TOGGLE_APPS, Menu.NONE, 218 mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps); 219 } 220 221 super.onCreateOptionsMenu(menu, inflater); 222 } 223 224 @Override getHelpResource()225 protected int getHelpResource() { 226 return R.string.help_url_battery; 227 } 228 229 @Override onOptionsItemSelected(MenuItem item)230 public boolean onOptionsItemSelected(MenuItem item) { 231 final SettingsActivity sa = (SettingsActivity) getActivity(); 232 final Context context = getContext(); 233 final MetricsFeatureProvider metricsFeatureProvider = 234 FeatureFactory.getFactory(context).getMetricsFeatureProvider(); 235 236 switch (item.getItemId()) { 237 case MENU_STATS_TYPE: 238 if (mStatsType == BatteryStats.STATS_SINCE_CHARGED) { 239 mStatsType = BatteryStats.STATS_SINCE_UNPLUGGED; 240 } else { 241 mStatsType = BatteryStats.STATS_SINCE_CHARGED; 242 } 243 refreshUi(); 244 return true; 245 case MENU_HIGH_POWER_APPS: 246 Bundle args = new Bundle(); 247 args.putString(ManageApplications.EXTRA_CLASSNAME, 248 HighPowerApplicationsActivity.class.getName()); 249 sa.startPreferencePanel(this, ManageApplications.class.getName(), args, 250 R.string.high_power_apps, null, null, 0); 251 metricsFeatureProvider.action(context, 252 MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_OPTIMIZATION); 253 return true; 254 case MENU_ADDITIONAL_BATTERY_INFO: 255 startActivity(FeatureFactory.getFactory(getContext()) 256 .getPowerUsageFeatureProvider(getContext()) 257 .getAdditionalBatteryInfoIntent()); 258 metricsFeatureProvider.action(context, 259 MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_USAGE_ALERTS); 260 return true; 261 case MENU_TOGGLE_APPS: 262 mShowAllApps = !mShowAllApps; 263 item.setTitle(mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps); 264 metricsFeatureProvider.action(context, 265 MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE, mShowAllApps); 266 restartBatteryStatsLoader(); 267 return true; 268 default: 269 return super.onOptionsItemSelected(item); 270 } 271 } 272 273 @VisibleForTesting restoreSavedInstance(Bundle savedInstance)274 void restoreSavedInstance(Bundle savedInstance) { 275 if (savedInstance != null) { 276 mShowAllApps = savedInstance.getBoolean(KEY_SHOW_ALL_APPS, false); 277 } 278 } 279 addNotAvailableMessage()280 private void addNotAvailableMessage() { 281 final String NOT_AVAILABLE = "not_available"; 282 Preference notAvailable = getCachedPreference(NOT_AVAILABLE); 283 if (notAvailable == null) { 284 notAvailable = new Preference(getPrefContext()); 285 notAvailable.setKey(NOT_AVAILABLE); 286 notAvailable.setTitle(R.string.power_usage_not_available); 287 mAppListGroup.addPreference(notAvailable); 288 } 289 } 290 performBatteryHeaderClick()291 private void performBatteryHeaderClick() { 292 final Context context = getContext(); 293 final PowerUsageFeatureProvider featureProvider = FeatureFactory.getFactory(context) 294 .getPowerUsageFeatureProvider(context); 295 296 if (featureProvider.isAdvancedUiEnabled()) { 297 Utils.startWithFragment(getContext(), PowerUsageAdvanced.class.getName(), null, 298 null, 0, R.string.advanced_battery_title, null, getMetricsCategory()); 299 } else { 300 mStatsHelper.storeStatsHistoryInFile(BatteryHistoryDetail.BATTERY_HISTORY_FILE); 301 Bundle args = new Bundle(2); 302 args.putString(BatteryHistoryDetail.EXTRA_STATS, 303 BatteryHistoryDetail.BATTERY_HISTORY_FILE); 304 args.putParcelable(BatteryHistoryDetail.EXTRA_BROADCAST, 305 mStatsHelper.getBatteryBroadcast()); 306 Utils.startWithFragment(getContext(), BatteryHistoryDetail.class.getName(), args, 307 null, 0, R.string.history_details_title, null, getMetricsCategory()); 308 } 309 } 310 isSharedGid(int uid)311 private static boolean isSharedGid(int uid) { 312 return UserHandle.getAppIdFromSharedAppGid(uid) > 0; 313 } 314 isSystemUid(int uid)315 private static boolean isSystemUid(int uid) { 316 return uid >= Process.SYSTEM_UID && uid < Process.FIRST_APPLICATION_UID; 317 } 318 319 /** 320 * We want to coalesce some UIDs. For example, dex2oat runs under a shared gid that 321 * exists for all users of the same app. We detect this case and merge the power use 322 * for dex2oat to the device OWNER's use of the app. 323 * 324 * @return A sorted list of apps using power. 325 */ getCoalescedUsageList(final List<BatterySipper> sippers)326 private List<BatterySipper> getCoalescedUsageList(final List<BatterySipper> sippers) { 327 final SparseArray<BatterySipper> uidList = new SparseArray<>(); 328 329 final ArrayList<BatterySipper> results = new ArrayList<>(); 330 final int numSippers = sippers.size(); 331 for (int i = 0; i < numSippers; i++) { 332 BatterySipper sipper = sippers.get(i); 333 if (sipper.getUid() > 0) { 334 int realUid = sipper.getUid(); 335 336 // Check if this UID is a shared GID. If so, we combine it with the OWNER's 337 // actual app UID. 338 if (isSharedGid(sipper.getUid())) { 339 realUid = UserHandle.getUid(UserHandle.USER_SYSTEM, 340 UserHandle.getAppIdFromSharedAppGid(sipper.getUid())); 341 } 342 343 // Check if this UID is a system UID (mediaserver, logd, nfc, drm, etc). 344 if (isSystemUid(realUid) 345 && !"mediaserver".equals(sipper.packageWithHighestDrain)) { 346 // Use the system UID for all UIDs running in their own sandbox that 347 // are not apps. We exclude mediaserver because we already are expected to 348 // report that as a separate item. 349 realUid = Process.SYSTEM_UID; 350 } 351 352 if (realUid != sipper.getUid()) { 353 // Replace the BatterySipper with a new one with the real UID set. 354 BatterySipper newSipper = new BatterySipper(sipper.drainType, 355 new FakeUid(realUid), 0.0); 356 newSipper.add(sipper); 357 newSipper.packageWithHighestDrain = sipper.packageWithHighestDrain; 358 newSipper.mPackages = sipper.mPackages; 359 sipper = newSipper; 360 } 361 362 int index = uidList.indexOfKey(realUid); 363 if (index < 0) { 364 // New entry. 365 uidList.put(realUid, sipper); 366 } else { 367 // Combine BatterySippers if we already have one with this UID. 368 final BatterySipper existingSipper = uidList.valueAt(index); 369 existingSipper.add(sipper); 370 if (existingSipper.packageWithHighestDrain == null 371 && sipper.packageWithHighestDrain != null) { 372 existingSipper.packageWithHighestDrain = sipper.packageWithHighestDrain; 373 } 374 375 final int existingPackageLen = existingSipper.mPackages != null ? 376 existingSipper.mPackages.length : 0; 377 final int newPackageLen = sipper.mPackages != null ? 378 sipper.mPackages.length : 0; 379 if (newPackageLen > 0) { 380 String[] newPackages = new String[existingPackageLen + newPackageLen]; 381 if (existingPackageLen > 0) { 382 System.arraycopy(existingSipper.mPackages, 0, newPackages, 0, 383 existingPackageLen); 384 } 385 System.arraycopy(sipper.mPackages, 0, newPackages, existingPackageLen, 386 newPackageLen); 387 existingSipper.mPackages = newPackages; 388 } 389 } 390 } else { 391 results.add(sipper); 392 } 393 } 394 395 final int numUidSippers = uidList.size(); 396 for (int i = 0; i < numUidSippers; i++) { 397 results.add(uidList.valueAt(i)); 398 } 399 400 // The sort order must have changed, so re-sort based on total power use. 401 mBatteryUtils.sortUsageList(results); 402 return results; 403 } 404 refreshUi()405 protected void refreshUi() { 406 final Context context = getContext(); 407 if (context == null) { 408 return; 409 } 410 411 cacheRemoveAllPrefs(mAppListGroup); 412 mAppListGroup.setOrderingAsAdded(false); 413 boolean addedSome = false; 414 415 final PowerProfile powerProfile = mStatsHelper.getPowerProfile(); 416 final BatteryStats stats = mStatsHelper.getStats(); 417 final double averagePower = powerProfile.getAveragePower(PowerProfile.POWER_SCREEN_FULL); 418 419 final long elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000; 420 Intent batteryBroadcast = context.registerReceiver(null, 421 new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); 422 BatteryInfo batteryInfo = BatteryInfo.getBatteryInfo(context, batteryBroadcast, 423 mStatsHelper.getStats(), elapsedRealtimeUs, false); 424 mBatteryHeaderPreferenceController.updateHeaderPreference(batteryInfo); 425 426 final TypedValue value = new TypedValue(); 427 context.getTheme().resolveAttribute(android.R.attr.colorControlNormal, value, true); 428 final int colorControl = context.getColor(value.resourceId); 429 final int dischargeAmount = USE_FAKE_DATA ? 5000 430 : stats != null ? stats.getDischargeAmount(mStatsType) : 0; 431 432 final long lastFullChargeTime = mBatteryUtils.calculateLastFullChargeTime(mStatsHelper, 433 System.currentTimeMillis()); 434 updateScreenPreference(); 435 updateLastFullChargePreference(lastFullChargeTime); 436 437 final CharSequence timeSequence = Utils.formatElapsedTime(context, lastFullChargeTime, 438 false); 439 final int resId = mShowAllApps ? R.string.power_usage_list_summary_device 440 : R.string.power_usage_list_summary; 441 mAppListGroup.setTitle(TextUtils.expandTemplate(getText(resId), timeSequence)); 442 443 if (averagePower >= MIN_AVERAGE_POWER_THRESHOLD_MILLI_AMP || USE_FAKE_DATA) { 444 final List<BatterySipper> usageList = getCoalescedUsageList( 445 USE_FAKE_DATA ? getFakeStats() : mStatsHelper.getUsageList()); 446 double hiddenPowerMah = mShowAllApps ? 0 : 447 mBatteryUtils.removeHiddenBatterySippers(usageList); 448 mBatteryUtils.sortUsageList(usageList); 449 450 final int numSippers = usageList.size(); 451 for (int i = 0; i < numSippers; i++) { 452 final BatterySipper sipper = usageList.get(i); 453 double totalPower = USE_FAKE_DATA ? 4000 : mStatsHelper.getTotalPower(); 454 455 final double percentOfTotal = mBatteryUtils.calculateBatteryPercent( 456 sipper.totalPowerMah, totalPower, hiddenPowerMah, dischargeAmount); 457 458 if (((int) (percentOfTotal + .5)) < 1) { 459 continue; 460 } 461 if (sipper.drainType == BatterySipper.DrainType.OVERCOUNTED) { 462 // Don't show over-counted unless it is at least 2/3 the size of 463 // the largest real entry, and its percent of total is more significant 464 if (sipper.totalPowerMah < ((mStatsHelper.getMaxRealPower() * 2) / 3)) { 465 continue; 466 } 467 if (percentOfTotal < 10) { 468 continue; 469 } 470 if ("user".equals(Build.TYPE)) { 471 continue; 472 } 473 } 474 if (sipper.drainType == BatterySipper.DrainType.UNACCOUNTED) { 475 // Don't show over-counted unless it is at least 1/2 the size of 476 // the largest real entry, and its percent of total is more significant 477 if (sipper.totalPowerMah < (mStatsHelper.getMaxRealPower() / 2)) { 478 continue; 479 } 480 if (percentOfTotal < 5) { 481 continue; 482 } 483 if ("user".equals(Build.TYPE)) { 484 continue; 485 } 486 } 487 final UserHandle userHandle = new UserHandle(UserHandle.getUserId(sipper.getUid())); 488 final BatteryEntry entry = new BatteryEntry(getActivity(), mHandler, mUm, sipper); 489 final Drawable badgedIcon = mUm.getBadgedIconForUser(entry.getIcon(), 490 userHandle); 491 final CharSequence contentDescription = mUm.getBadgedLabelForUser(entry.getLabel(), 492 userHandle); 493 494 final String key = extractKeyFromSipper(sipper); 495 PowerGaugePreference pref = (PowerGaugePreference) getCachedPreference(key); 496 if (pref == null) { 497 pref = new PowerGaugePreference(getPrefContext(), badgedIcon, 498 contentDescription, entry); 499 pref.setKey(key); 500 } 501 502 final double percentOfMax = (sipper.totalPowerMah * 100) 503 / mStatsHelper.getMaxPower(); 504 sipper.percent = percentOfTotal; 505 pref.setTitle(entry.getLabel()); 506 pref.setOrder(i + 1); 507 pref.setPercent(percentOfTotal); 508 if (sipper.usageTimeMs == 0 && sipper.drainType == DrainType.APP) { 509 sipper.usageTimeMs = mBatteryUtils.getProcessTimeMs( 510 BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, mStatsType); 511 } 512 setUsageSummary(pref, sipper); 513 if ((sipper.drainType != DrainType.APP 514 || sipper.uidObj.getUid() == Process.ROOT_UID) 515 && sipper.drainType != DrainType.USER) { 516 pref.setTint(colorControl); 517 } 518 addedSome = true; 519 mAppListGroup.addPreference(pref); 520 if (mAppListGroup.getPreferenceCount() - getCachedCount() 521 > (MAX_ITEMS_TO_LIST + 1)) { 522 break; 523 } 524 } 525 } 526 if (!addedSome) { 527 addNotAvailableMessage(); 528 } 529 removeCachedPrefs(mAppListGroup); 530 531 BatteryEntry.startRequestQueue(); 532 } 533 534 @VisibleForTesting findBatterySipperByType(List<BatterySipper> usageList, DrainType type)535 BatterySipper findBatterySipperByType(List<BatterySipper> usageList, DrainType type) { 536 for (int i = 0, size = usageList.size(); i < size; i++) { 537 final BatterySipper sipper = usageList.get(i); 538 if (sipper.drainType == type) { 539 return sipper; 540 } 541 } 542 return null; 543 } 544 545 @VisibleForTesting updateScreenPreference()546 void updateScreenPreference() { 547 final BatterySipper sipper = findBatterySipperByType( 548 mStatsHelper.getUsageList(), DrainType.SCREEN); 549 final long usageTimeMs = sipper != null ? sipper.usageTimeMs : 0; 550 551 mScreenUsagePref.setSubtitle(Utils.formatElapsedTime(getContext(), usageTimeMs, false)); 552 } 553 554 @VisibleForTesting updateLastFullChargePreference(long timeMs)555 void updateLastFullChargePreference(long timeMs) { 556 final CharSequence timeSequence = Utils.formatElapsedTime(getContext(), timeMs, false); 557 mLastFullChargePref.setSubtitle( 558 TextUtils.expandTemplate(getText(R.string.power_last_full_charge_summary), 559 timeSequence)); 560 } 561 562 @VisibleForTesting calculateRunningTimeBasedOnStatsType()563 long calculateRunningTimeBasedOnStatsType() { 564 final long elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000; 565 // Return the battery time (millisecond) on status mStatsType 566 return mStatsHelper.getStats().computeBatteryRealtime(elapsedRealtimeUs, 567 mStatsType /* STATS_SINCE_CHARGED */) / 1000; 568 } 569 570 @VisibleForTesting calculatePercentage(double powerUsage, double dischargeAmount)571 double calculatePercentage(double powerUsage, double dischargeAmount) { 572 final double totalPower = mStatsHelper.getTotalPower(); 573 return totalPower == 0 ? 0 : 574 ((powerUsage / totalPower) * dischargeAmount); 575 } 576 577 @VisibleForTesting setUsageSummary(Preference preference, BatterySipper sipper)578 void setUsageSummary(Preference preference, BatterySipper sipper) { 579 // Only show summary when usage time is longer than one minute 580 final long usageTimeMs = sipper.usageTimeMs; 581 if (usageTimeMs >= DateUtils.MINUTE_IN_MILLIS) { 582 final CharSequence timeSequence = Utils.formatElapsedTime(getContext(), usageTimeMs, 583 false); 584 preference.setSummary(mBatteryUtils.shouldHideSipper(sipper) ? timeSequence : 585 TextUtils.expandTemplate(getText(R.string.battery_screen_usage), timeSequence)); 586 } 587 } 588 589 @VisibleForTesting extractKeyFromSipper(BatterySipper sipper)590 String extractKeyFromSipper(BatterySipper sipper) { 591 if (sipper.uidObj != null) { 592 return Integer.toString(sipper.getUid()); 593 } else if (sipper.drainType != DrainType.APP) { 594 return sipper.drainType.toString(); 595 } else if (sipper.getPackages() != null) { 596 return TextUtils.concat(sipper.getPackages()).toString(); 597 } else { 598 Log.w(TAG, "Inappropriate BatterySipper without uid and package names: " + sipper); 599 return "-1"; 600 } 601 } 602 603 @VisibleForTesting setBatteryLayoutPreference(LayoutPreference layoutPreference)604 void setBatteryLayoutPreference(LayoutPreference layoutPreference) { 605 mBatteryLayoutPref = layoutPreference; 606 } 607 608 @VisibleForTesting initFeatureProvider()609 void initFeatureProvider() { 610 final Context context = getContext(); 611 mPowerFeatureProvider = FeatureFactory.getFactory(context) 612 .getPowerUsageFeatureProvider(context); 613 } 614 getFakeStats()615 private static List<BatterySipper> getFakeStats() { 616 ArrayList<BatterySipper> stats = new ArrayList<>(); 617 float use = 5; 618 for (DrainType type : DrainType.values()) { 619 if (type == DrainType.APP) { 620 continue; 621 } 622 stats.add(new BatterySipper(type, null, use)); 623 use += 5; 624 } 625 for (int i = 0; i < 100; i++) { 626 stats.add(new BatterySipper(DrainType.APP, 627 new FakeUid(Process.FIRST_APPLICATION_UID + i), use)); 628 } 629 stats.add(new BatterySipper(DrainType.APP, 630 new FakeUid(0), use)); 631 632 // Simulate dex2oat process. 633 BatterySipper sipper = new BatterySipper(DrainType.APP, 634 new FakeUid(UserHandle.getSharedAppGid(Process.FIRST_APPLICATION_UID)), 10.0f); 635 sipper.packageWithHighestDrain = "dex2oat"; 636 stats.add(sipper); 637 638 sipper = new BatterySipper(DrainType.APP, 639 new FakeUid(UserHandle.getSharedAppGid(Process.FIRST_APPLICATION_UID + 1)), 10.0f); 640 sipper.packageWithHighestDrain = "dex2oat"; 641 stats.add(sipper); 642 643 sipper = new BatterySipper(DrainType.APP, 644 new FakeUid(UserHandle.getSharedAppGid(Process.LOG_UID)), 9.0f); 645 stats.add(sipper); 646 647 return stats; 648 } 649 650 Handler mHandler = new Handler() { 651 652 @Override 653 public void handleMessage(Message msg) { 654 switch (msg.what) { 655 case BatteryEntry.MSG_UPDATE_NAME_ICON: 656 BatteryEntry entry = (BatteryEntry) msg.obj; 657 PowerGaugePreference pgp = 658 (PowerGaugePreference) findPreference( 659 Integer.toString(entry.sipper.uidObj.getUid())); 660 if (pgp != null) { 661 final int userId = UserHandle.getUserId(entry.sipper.getUid()); 662 final UserHandle userHandle = new UserHandle(userId); 663 pgp.setIcon(mUm.getBadgedIconForUser(entry.getIcon(), userHandle)); 664 pgp.setTitle(entry.name); 665 if (entry.sipper.drainType == DrainType.APP) { 666 pgp.setContentDescription(entry.name); 667 } 668 } 669 break; 670 case BatteryEntry.MSG_REPORT_FULLY_DRAWN: 671 Activity activity = getActivity(); 672 if (activity != null) { 673 activity.reportFullyDrawn(); 674 } 675 break; 676 } 677 super.handleMessage(msg); 678 } 679 }; 680 681 private static class SummaryProvider implements SummaryLoader.SummaryProvider { 682 private final Context mContext; 683 private final SummaryLoader mLoader; 684 private final BatteryBroadcastReceiver mBatteryBroadcastReceiver; 685 SummaryProvider(Context context, SummaryLoader loader)686 private SummaryProvider(Context context, SummaryLoader loader) { 687 mContext = context; 688 mLoader = loader; 689 mBatteryBroadcastReceiver = new BatteryBroadcastReceiver(mContext); 690 mBatteryBroadcastReceiver.setBatteryChangedListener(() -> { 691 BatteryInfo.getBatteryInfo(mContext, new BatteryInfo.Callback() { 692 @Override 693 public void onBatteryInfoLoaded(BatteryInfo info) { 694 mLoader.setSummary(SummaryProvider.this, info.chargeLabelString); 695 } 696 }); 697 }); 698 } 699 700 @Override setListening(boolean listening)701 public void setListening(boolean listening) { 702 if (listening) { 703 mBatteryBroadcastReceiver.register(); 704 } else { 705 mBatteryBroadcastReceiver.unRegister(); 706 } 707 } 708 } 709 710 public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = 711 new BaseSearchIndexProvider() { 712 @Override 713 public List<SearchIndexableResource> getXmlResourcesToIndex( 714 Context context, boolean enabled) { 715 final SearchIndexableResource sir = new SearchIndexableResource(context); 716 sir.xmlResId = R.xml.power_usage_summary; 717 return Arrays.asList(sir); 718 } 719 720 @Override 721 public List<String> getNonIndexableKeys(Context context) { 722 List<String> niks = new ArrayList<>(); 723 // Duplicates in display 724 niks.add(KEY_AUTO_BRIGHTNESS); 725 niks.add(KEY_SCREEN_TIMEOUT); 726 niks.add(KEY_BATTERY_SAVER_SUMMARY); 727 return niks; 728 } 729 }; 730 731 public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY 732 = new SummaryLoader.SummaryProviderFactory() { 733 @Override 734 public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity, 735 SummaryLoader summaryLoader) { 736 return new SummaryProvider(activity, summaryLoader); 737 } 738 }; 739 } 740