src/com/android/settings/fuelgauge/PowerUsageSummary.java

   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.animation.Animator;
  20 import android.animation.ValueAnimator;
  21 import android.app.Activity;
  22 import android.app.LoaderManager;
  23 import android.content.Context;
  24 import android.content.CursorLoader;
  25 import android.content.Intent;
  26 import android.content.IntentFilter;
  27 import android.content.Loader;
  28 import android.content.res.TypedArray;
  29 import android.content.res.Resources;
  30 import android.database.Cursor;
  31 import android.graphics.drawable.Drawable;
  32 import android.net.Uri;
  33 import android.os.BatteryStats;
  34 import android.os.Build;
  35 import android.os.Bundle;
  36 import android.os.Handler;
  37 import android.os.Message;
  38 import android.os.Process;
  39 import android.os.SystemClock;
  40 import android.os.UserHandle;
  41 import android.provider.SearchIndexableResource;
  42 import android.support.annotation.VisibleForTesting;
  43 import android.support.v7.preference.Preference;
  44 import android.support.v7.preference.PreferenceGroup;
  45 import android.text.TextUtils;
  46 import android.text.format.DateUtils;
  47 import android.text.format.Formatter;
  48 import android.util.Log;
  49 import android.util.SparseArray;
  50 import android.view.Menu;
  51 import android.view.MenuInflater;
  52 import android.view.MenuItem;
  53 import android.view.animation.AnimationUtils;
  54 import android.widget.TextView;
  55
  56 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
  57 import com.android.internal.os.BatterySipper;
  58 import com.android.internal.os.BatterySipper.DrainType;
  59 import com.android.internal.os.PowerProfile;
  60 import com.android.settings.R;
  61 import com.android.settings.Settings.HighPowerApplicationsActivity;
  62 import com.android.settings.SettingsActivity;
  63 import com.android.settings.Utils;
  64 import com.android.settings.applications.LayoutPreference;
  65 import com.android.settings.applications.ManageApplications;
  66 import com.android.settings.core.PreferenceController;
  67 import com.android.settings.core.instrumentation.MetricsFeatureProvider;
  68 import com.android.settings.dashboard.SummaryLoader;
  69 import com.android.settings.display.AutoBrightnessPreferenceController;
  70 import com.android.settings.display.BatteryPercentagePreferenceController;
  71 import com.android.settings.display.TimeoutPreferenceController;
  72 import com.android.settings.fuelgauge.anomaly.Anomaly;
  73 import com.android.settings.fuelgauge.anomaly.AnomalyDialogFragment;
  74 import com.android.settings.fuelgauge.anomaly.AnomalyLoader;
  75 import com.android.settings.fuelgauge.anomaly.AnomalySummaryPreferenceController;
  76 import com.android.settings.overlay.FeatureFactory;
  77 import com.android.settings.search.BaseSearchIndexProvider;
  78 import com.android.settingslib.BatteryInfo;
  79 import com.android.settingslib.widget.FooterPreferenceMixin;
  80
  81 import java.util.ArrayList;
  82 import java.util.Arrays;
  83 import java.util.Collections;
  84 import java.util.Comparator;
  85 import java.util.List;
  86
  87 /**
  88  * Displays a list of apps and subsystems that consume power, ordered by how much power was
  89  * consumed since the last time it was unplugged.
  90  */
  91 public class PowerUsageSummary extends PowerUsageBase implements
  92         AnomalyDialogFragment.AnomalyDialogListener {
  93
  94     static final String TAG = "PowerUsageSummary";
  95
  96     private static final boolean DEBUG = false;
  97     private static final boolean USE_FAKE_DATA = false;
  98     private static final String KEY_APP_LIST = "app_list";
  99     private static final String KEY_BATTERY_HEADER = "battery_header";
 100     private static final int MAX_ITEMS_TO_LIST = USE_FAKE_DATA ? 30 : 10;
 101     private static final int MIN_AVERAGE_POWER_THRESHOLD_MILLI_AMP = 10;
 102     private static final int BATTERY_ANIMATION_DURATION_MS_PER_LEVEL = 30;
 103
 104     @VisibleForTesting
 105     static final String ARG_BATTERY_LEVEL = "key_battery_level";
 106
 107     private static final String KEY_SCREEN_USAGE = "screen_usage";
 108     private static final String KEY_TIME_SINCE_LAST_FULL_CHARGE = "last_full_charge";
 109
 110     private static final String KEY_AUTO_BRIGHTNESS = "auto_brightness_battery";
 111     private static final String KEY_SCREEN_TIMEOUT = "screen_timeout_battery";
 112     private static final String KEY_BATTERY_SAVER_SUMMARY = "battery_saver_summary";
 113
 114     @VisibleForTesting
 115     static final int ANOMALY_LOADER = 1;
 116     private static final int BATTERY_ESTIMATE_LOADER = 2;
 117     private static final int MENU_STATS_TYPE = Menu.FIRST;
 118     @VisibleForTesting
 119     static final int MENU_HIGH_POWER_APPS = Menu.FIRST + 3;
 120     @VisibleForTesting
 121     static final int MENU_ADDITIONAL_BATTERY_INFO = Menu.FIRST + 4;
 122     @VisibleForTesting
 123     static final int MENU_TOGGLE_APPS = Menu.FIRST + 5;
 124     private static final int MENU_HELP = Menu.FIRST + 6;
 125
 126     private final FooterPreferenceMixin mFooterPreferenceMixin =
 127             new FooterPreferenceMixin(this, getLifecycle());
 128
 129     @VisibleForTesting
 130     int mBatteryLevel;
 131     @VisibleForTesting
 132     boolean mShowAllApps = false;
 133     @VisibleForTesting
 134     PowerGaugePreference mScreenUsagePref;
 135     @VisibleForTesting
 136     PowerGaugePreference mLastFullChargePref;
 137     @VisibleForTesting
 138     PowerUsageFeatureProvider mPowerFeatureProvider;
 139     @VisibleForTesting
 140     BatteryUtils mBatteryUtils;
 141     @VisibleForTesting
 142     long mEnhancedEstimate = -1;
 143
 144     /**
 145      * SparseArray that maps uid to {@link Anomaly}, so we could find {@link Anomaly} by uid
 146      */
 147     @VisibleForTesting
 148     SparseArray<List<Anomaly>> mAnomalySparseArray;
 149
 150     private LayoutPreference mBatteryLayoutPref;
 151     private PreferenceGroup mAppListGroup;
 152     private AnomalySummaryPreferenceController mAnomalySummaryPreferenceController;
 153     private int mStatsType = BatteryStats.STATS_SINCE_CHARGED;
 154
 155     private LoaderManager.LoaderCallbacks<List<Anomaly>> mAnomalyLoaderCallbacks =
 156             new LoaderManager.LoaderCallbacks<List<Anomaly>>() {
 157
 158                 @Override
 159                 public Loader<List<Anomaly>> onCreateLoader(int id, Bundle args) {
 160                     return new AnomalyLoader(getContext(), mStatsHelper);
 161                 }
 162
 163                 @Override
 164                 public void onLoadFinished(Loader<List<Anomaly>> loader, List<Anomaly> data) {
 165                     // show high usage preference if possible
 166                     mAnomalySummaryPreferenceController.updateAnomalySummaryPreference(data);
 167
 168                     updateAnomalySparseArray(data);
 169                     refreshAppListGroup();
 170                 }
 171
 172                 @Override
 173                 public void onLoaderReset(Loader<List<Anomaly>> loader) {
 174
 175                 }
 176             };
 177
 178     @VisibleForTesting
 179     LoaderManager.LoaderCallbacks<Cursor> mBatteryPredictionLoaderCallbacks =
 180             new LoaderManager.LoaderCallbacks<Cursor>() {
 181
 182                 @Override
 183                 public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
 184                     final Uri queryUri = mPowerFeatureProvider.getEnhancedBatteryPredictionUri();
 185                     return new CursorLoader(getContext(), queryUri, null, null, null, null);
 186                 }
 187
 188                 @Override
 189                 public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
 190                     if (cursor == null) {
 191                         return;
 192                     }
 193                     if (cursor.moveToFirst()) {
 194                         mEnhancedEstimate =
 195                                 mPowerFeatureProvider.getTimeRemainingEstimate(cursor);
 196                     }
 197                     final long elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000;
 198                     Intent batteryBroadcast = getContext().registerReceiver(null,
 199                             new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
 200                     BatteryInfo batteryInfo = BatteryInfo.getBatteryInfo(getContext(),
 201                             batteryBroadcast, mStatsHelper.getStats(), elapsedRealtimeUs, false);
 202                     useEnhancedEstimateIfAvailable(getContext(), batteryInfo);
 203                     updateHeaderPreference(batteryInfo);
 204                 }
 205
 206                 @Override
 207                 public void onLoaderReset(Loader<Cursor> loader) {
 208                     // do nothing
 209                 }
 210             };
 211
 212     @Override
 213     public void onCreate(Bundle icicle) {
 214         super.onCreate(icicle);
 215         setAnimationAllowed(true);
 216
 217         mBatteryLevel = getContext().getResources().getInteger(
 218                 com.android.internal.R.integer.config_criticalBatteryWarningLevel) + 1;
 219         mBatteryLayoutPref = (LayoutPreference) findPreference(KEY_BATTERY_HEADER);
 220         mAppListGroup = (PreferenceGroup) findPreference(KEY_APP_LIST);
 221         mScreenUsagePref = (PowerGaugePreference) findPreference(KEY_SCREEN_USAGE);
 222         mLastFullChargePref = (PowerGaugePreference) findPreference(
 223                 KEY_TIME_SINCE_LAST_FULL_CHARGE);
 224         mFooterPreferenceMixin.createFooterPreference().setTitle(R.string.battery_footer_summary);
 225         mAnomalySummaryPreferenceController = new AnomalySummaryPreferenceController(
 226                 (SettingsActivity) getActivity(), this, MetricsEvent.FUELGAUGE_POWER_USAGE_SUMMARY);
 227         mBatteryUtils = BatteryUtils.getInstance(getContext());
 228         mAnomalySparseArray = new SparseArray<>();
 229
 230         initFeatureProvider();
 231         if (mPowerFeatureProvider != null) {
 232             getLoaderManager().initLoader(BATTERY_ESTIMATE_LOADER, Bundle.EMPTY,
 233                     mBatteryPredictionLoaderCallbacks);
 234         }
 235     }
 236
 237     @Override
 238     public void onActivityCreated(Bundle savedInstanceState) {
 239         super.onActivityCreated(savedInstanceState);
 240         if (savedInstanceState != null) {
 241             mBatteryLevel = savedInstanceState.getInt(ARG_BATTERY_LEVEL);
 242         }
 243     }
 244
 245     @Override
 246     public int getMetricsCategory() {
 247         return MetricsEvent.FUELGAUGE_POWER_USAGE_SUMMARY;
 248     }
 249
 250     @Override
 251     public void onResume() {
 252         super.onResume();
 253
 254         initHeaderPreference();
 255     }
 256
 257     @Override
 258     public void onPause() {
 259         BatteryEntry.stopRequestQueue();
 260         mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON);
 261         super.onPause();
 262     }
 263
 264     @Override
 265     public void onDestroy() {
 266         super.onDestroy();
 267         if (getActivity().isChangingConfigurations()) {
 268             BatteryEntry.clearUidCache();
 269         }
 270     }
 271
 272     @Override
 273     public void onSaveInstanceState(Bundle outState) {
 274         super.onSaveInstanceState(outState);
 275         outState.putInt(ARG_BATTERY_LEVEL, mBatteryLevel);
 276     }
 277
 278     @Override
 279     public boolean onPreferenceTreeClick(Preference preference) {
 280         if (mAnomalySummaryPreferenceController.onPreferenceTreeClick(preference)) {
 281             return true;
 282         }
 283         if (KEY_BATTERY_HEADER.equals(preference.getKey())) {
 284             performBatteryHeaderClick();
 285             return true;
 286         } else if (!(preference instanceof PowerGaugePreference)) {
 287             return super.onPreferenceTreeClick(preference);
 288         }
 289         PowerGaugePreference pgp = (PowerGaugePreference) preference;
 290         BatteryEntry entry = pgp.getInfo();
 291         AdvancedPowerUsageDetail.startBatteryDetailPage((SettingsActivity) getActivity(),
 292                 this, mStatsHelper, mStatsType, entry, pgp.getPercent());
 293         return super.onPreferenceTreeClick(preference);
 294     }
 295
 296     @Override
 297     protected String getLogTag() {
 298         return TAG;
 299     }
 300
 301     @Override
 302     protected int getPreferenceScreenResId() {
 303         return R.xml.power_usage_summary;
 304     }
 305
 306     @Override
 307     protected List<PreferenceController> getPreferenceControllers(Context context) {
 308         final List<PreferenceController> controllers = new ArrayList<>();
 309         controllers.add(new AutoBrightnessPreferenceController(context, KEY_AUTO_BRIGHTNESS));
 310         controllers.add(new TimeoutPreferenceController(context, KEY_SCREEN_TIMEOUT));
 311         controllers.add(new BatterySaverController(context, getLifecycle()));
 312         controllers.add(new BatteryPercentagePreferenceController(context));
 313         return controllers;
 314     }
 315
 316     @Override
 317     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
 318         if (DEBUG) {
 319             menu.add(Menu.NONE, MENU_STATS_TYPE, Menu.NONE, R.string.menu_stats_total)
 320                     .setIcon(com.android.internal.R.drawable.ic_menu_info_details)
 321                     .setAlphabeticShortcut('t');
 322         }
 323
 324         menu.add(Menu.NONE, MENU_HIGH_POWER_APPS, Menu.NONE, R.string.high_power_apps);
 325
 326         if (mPowerFeatureProvider.isAdditionalBatteryInfoEnabled()) {
 327             menu.add(Menu.NONE, MENU_ADDITIONAL_BATTERY_INFO,
 328                     Menu.NONE, R.string.additional_battery_info);
 329         }
 330         if (mPowerFeatureProvider.isPowerAccountingToggleEnabled()) {
 331             menu.add(Menu.NONE, MENU_TOGGLE_APPS, Menu.NONE,
 332                     mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps);
 333         }
 334
 335         super.onCreateOptionsMenu(menu, inflater);
 336     }
 337
 338     @Override
 339     protected int getHelpResource() {
 340         return R.string.help_url_battery;
 341     }
 342
 343     @Override
 344     public boolean onOptionsItemSelected(MenuItem item) {
 345         final SettingsActivity sa = (SettingsActivity) getActivity();
 346         final Context context = getContext();
 347         final MetricsFeatureProvider metricsFeatureProvider =
 348                 FeatureFactory.getFactory(context).getMetricsFeatureProvider();
 349
 350         switch (item.getItemId()) {
 351             case MENU_STATS_TYPE:
 352                 if (mStatsType == BatteryStats.STATS_SINCE_CHARGED) {
 353                     mStatsType = BatteryStats.STATS_SINCE_UNPLUGGED;
 354                 } else {
 355                     mStatsType = BatteryStats.STATS_SINCE_CHARGED;
 356                 }
 357                 refreshUi();
 358                 return true;
 359             case MENU_HIGH_POWER_APPS:
 360                 Bundle args = new Bundle();
 361                 args.putString(ManageApplications.EXTRA_CLASSNAME,
 362                         HighPowerApplicationsActivity.class.getName());
 363                 sa.startPreferencePanel(this, ManageApplications.class.getName(), args,
 364                         R.string.high_power_apps, null, null, 0);
 365                 metricsFeatureProvider.action(context,
 366                         MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_OPTIMIZATION);
 367                 return true;
 368             case MENU_ADDITIONAL_BATTERY_INFO:
 369                 startActivity(FeatureFactory.getFactory(getContext())
 370                         .getPowerUsageFeatureProvider(getContext())
 371                         .getAdditionalBatteryInfoIntent());
 372                 metricsFeatureProvider.action(context,
 373                         MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_USAGE_ALERTS);
 374                 return true;
 375             case MENU_TOGGLE_APPS:
 376                 mShowAllApps = !mShowAllApps;
 377                 item.setTitle(mShowAllApps ? R.string.hide_extra_apps : R.string.show_all_apps);
 378                 metricsFeatureProvider.action(context,
 379                         MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE, mShowAllApps);
 380                 restartBatteryStatsLoader();
 381                 return true;
 382             default:
 383                 return super.onOptionsItemSelected(item);
 384         }
 385     }
 386
 387     private void addNotAvailableMessage() {
 388         final String NOT_AVAILABLE = "not_available";
 389         Preference notAvailable = getCachedPreference(NOT_AVAILABLE);
 390         if (notAvailable == null) {
 391             notAvailable = new Preference(getPrefContext());
 392             notAvailable.setKey(NOT_AVAILABLE);
 393             notAvailable.setTitle(R.string.power_usage_not_available);
 394             mAppListGroup.addPreference(notAvailable);
 395         }
 396     }
 397
 398     private void performBatteryHeaderClick() {
 399         final Context context = getContext();
 400         final PowerUsageFeatureProvider featureProvider = FeatureFactory.getFactory(context)
 401                 .getPowerUsageFeatureProvider(context);
 402
 403         if (featureProvider.isAdvancedUiEnabled()) {
 404             Utils.startWithFragment(getContext(), PowerUsageAdvanced.class.getName(), null,
 405                     null, 0, R.string.advanced_battery_title, null, getMetricsCategory());
 406         } else {
 407             mStatsHelper.storeStatsHistoryInFile(BatteryHistoryDetail.BATTERY_HISTORY_FILE);
 408             Bundle args = new Bundle(2);
 409             args.putString(BatteryHistoryDetail.EXTRA_STATS,
 410                     BatteryHistoryDetail.BATTERY_HISTORY_FILE);
 411             args.putParcelable(BatteryHistoryDetail.EXTRA_BROADCAST,
 412                     mStatsHelper.getBatteryBroadcast());
 413             Utils.startWithFragment(getContext(), BatteryHistoryDetail.class.getName(), args,
 414                     null, 0, R.string.history_details_title, null, getMetricsCategory());
 415         }
 416     }
 417
 418     private static boolean isSharedGid(int uid) {
 419         return UserHandle.getAppIdFromSharedAppGid(uid) > 0;
 420     }
 421
 422     private static boolean isSystemUid(int uid) {
 423         return uid >= Process.SYSTEM_UID && uid < Process.FIRST_APPLICATION_UID;
 424     }
 425
 426     /**
 427      * We want to coalesce some UIDs. For example, dex2oat runs under a shared gid that
 428      * exists for all users of the same app. We detect this case and merge the power use
 429      * for dex2oat to the device OWNER's use of the app.
 430      *
 431      * @return A sorted list of apps using power.
 432      */
 433     private static List<BatterySipper> getCoalescedUsageList(final List<BatterySipper> sippers) {
 434         final SparseArray<BatterySipper> uidList = new SparseArray<>();
 435
 436         final ArrayList<BatterySipper> results = new ArrayList<>();
 437         final int numSippers = sippers.size();
 438         for (int i = 0; i < numSippers; i++) {
 439             BatterySipper sipper = sippers.get(i);
 440             if (sipper.getUid() > 0) {
 441                 int realUid = sipper.getUid();
 442
 443                 // Check if this UID is a shared GID. If so, we combine it with the OWNER's
 444                 // actual app UID.
 445                 if (isSharedGid(sipper.getUid())) {
 446                     realUid = UserHandle.getUid(UserHandle.USER_SYSTEM,
 447                             UserHandle.getAppIdFromSharedAppGid(sipper.getUid()));
 448                 }
 449
 450                 // Check if this UID is a system UID (mediaserver, logd, nfc, drm, etc).
 451                 if (isSystemUid(realUid)
 452                         && !"mediaserver".equals(sipper.packageWithHighestDrain)) {
 453                     // Use the system UID for all UIDs running in their own sandbox that
 454                     // are not apps. We exclude mediaserver because we already are expected to
 455                     // report that as a separate item.
 456                     realUid = Process.SYSTEM_UID;
 457                 }
 458
 459                 if (realUid != sipper.getUid()) {
 460                     // Replace the BatterySipper with a new one with the real UID set.
 461                     BatterySipper newSipper = new BatterySipper(sipper.drainType,
 462                             new FakeUid(realUid), 0.0);
 463                     newSipper.add(sipper);
 464                     newSipper.packageWithHighestDrain = sipper.packageWithHighestDrain;
 465                     newSipper.mPackages = sipper.mPackages;
 466                     sipper = newSipper;
 467                 }
 468
 469                 int index = uidList.indexOfKey(realUid);
 470                 if (index < 0) {
 471                     // New entry.
 472                     uidList.put(realUid, sipper);
 473                 } else {
 474                     // Combine BatterySippers if we already have one with this UID.
 475                     final BatterySipper existingSipper = uidList.valueAt(index);
 476                     existingSipper.add(sipper);
 477                     if (existingSipper.packageWithHighestDrain == null
 478                             && sipper.packageWithHighestDrain != null) {
 479                         existingSipper.packageWithHighestDrain = sipper.packageWithHighestDrain;
 480                     }
 481
 482                     final int existingPackageLen = existingSipper.mPackages != null ?
 483                             existingSipper.mPackages.length : 0;
 484                     final int newPackageLen = sipper.mPackages != null ?
 485                             sipper.mPackages.length : 0;
 486                     if (newPackageLen > 0) {
 487                         String[] newPackages = new String[existingPackageLen + newPackageLen];
 488                         if (existingPackageLen > 0) {
 489                             System.arraycopy(existingSipper.mPackages, 0, newPackages, 0,
 490                                     existingPackageLen);
 491                         }
 492                         System.arraycopy(sipper.mPackages, 0, newPackages, existingPackageLen,
 493                                 newPackageLen);
 494                         existingSipper.mPackages = newPackages;
 495                     }
 496                 }
 497             } else {
 498                 results.add(sipper);
 499             }
 500         }
 501
 502         final int numUidSippers = uidList.size();
 503         for (int i = 0; i < numUidSippers; i++) {
 504             results.add(uidList.valueAt(i));
 505         }
 506
 507         // The sort order must have changed, so re-sort based on total power use.
 508         Collections.sort(results, new Comparator<BatterySipper>() {
 509             @Override
 510             public int compare(BatterySipper a, BatterySipper b) {
 511                 return Double.compare(b.totalPowerMah, a.totalPowerMah);
 512             }
 513         });
 514         return results;
 515     }
 516
 517     protected void refreshUi() {
 518         final Context context = getContext();
 519         if (context == null) {
 520             return;
 521         }
 522
 523         initAnomalyDetectionIfPossible();
 524
 525         final long elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000;
 526         Intent batteryBroadcast = context.registerReceiver(null,
 527                 new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
 528         BatteryInfo batteryInfo = BatteryInfo.getBatteryInfo(context, batteryBroadcast,
 529                 mStatsHelper.getStats(), elapsedRealtimeUs, false);
 530         useEnhancedEstimateIfAvailable(context, batteryInfo);
 531         updateHeaderPreference(batteryInfo);
 532
 533         final long runningTime = calculateRunningTimeBasedOnStatsType();
 534         updateScreenPreference();
 535         updateLastFullChargePreference(runningTime);
 536
 537         final CharSequence timeSequence = Utils.formatElapsedTime(context, runningTime, false);
 538         mAppListGroup.setTitle(
 539                 TextUtils.expandTemplate(getText(R.string.power_usage_list_summary), timeSequence));
 540
 541         refreshAppListGroup();
 542     }
 543
 544     private void refreshAppListGroup() {
 545         final Context context = getContext();
 546         final PowerProfile powerProfile = mStatsHelper.getPowerProfile();
 547         final BatteryStats stats = mStatsHelper.getStats();
 548         final double averagePower = powerProfile.getAveragePower(PowerProfile.POWER_SCREEN_FULL);
 549         boolean addedSome = false;
 550
 551         TypedArray array = context.obtainStyledAttributes(
 552                 new int[]{android.R.attr.colorControlNormal});
 553         final int colorControl = array.getColor(0, 0);
 554         array.recycle();
 555
 556         final int dischargeAmount = USE_FAKE_DATA ? 5000
 557                 : stats != null ? stats.getDischargeAmount(mStatsType) : 0;
 558
 559         cacheRemoveAllPrefs(mAppListGroup);
 560         mAppListGroup.setOrderingAsAdded(false);
 561
 562         if (averagePower >= MIN_AVERAGE_POWER_THRESHOLD_MILLI_AMP || USE_FAKE_DATA) {
 563             final List<BatterySipper> usageList = getCoalescedUsageList(
 564                     USE_FAKE_DATA ? getFakeStats() : mStatsHelper.getUsageList());
 565
 566             double hiddenPowerMah = mShowAllApps ? 0 :
 567                     mBatteryUtils.removeHiddenBatterySippers(usageList);
 568
 569             final int numSippers = usageList.size();
 570             for (int i = 0; i < numSippers; i++) {
 571                 final BatterySipper sipper = usageList.get(i);
 572                 double totalPower = USE_FAKE_DATA ? 4000 : mStatsHelper.getTotalPower();
 573
 574                 final double percentOfTotal = mBatteryUtils.calculateBatteryPercent(
 575                         sipper.totalPowerMah, totalPower, hiddenPowerMah, dischargeAmount);
 576
 577                 if (((int) (percentOfTotal + .5)) < 1) {
 578                     continue;
 579                 }
 580                 if (sipper.drainType == BatterySipper.DrainType.OVERCOUNTED) {
 581                     // Don't show over-counted unless it is at least 2/3 the size of
 582                     // the largest real entry, and its percent of total is more significant
 583                     if (sipper.totalPowerMah < ((mStatsHelper.getMaxRealPower() * 2) / 3)) {
 584                         continue;
 585                     }
 586                     if (percentOfTotal < 10) {
 587                         continue;
 588                     }
 589                     if ("user".equals(Build.TYPE)) {
 590                         continue;
 591                     }
 592                 }
 593                 if (sipper.drainType == BatterySipper.DrainType.UNACCOUNTED) {
 594                     // Don't show over-counted unless it is at least 1/2 the size of
 595                     // the largest real entry, and its percent of total is more significant
 596                     if (sipper.totalPowerMah < (mStatsHelper.getMaxRealPower() / 2)) {
 597                         continue;
 598                     }
 599                     if (percentOfTotal < 5) {
 600                         continue;
 601                     }
 602                     if ("user".equals(Build.TYPE)) {
 603                         continue;
 604                     }
 605                 }
 606                 final UserHandle userHandle = new UserHandle(UserHandle.getUserId(sipper.getUid()));
 607                 final BatteryEntry entry = new BatteryEntry(getActivity(), mHandler, mUm, sipper);
 608                 final Drawable badgedIcon = mUm.getBadgedIconForUser(entry.getIcon(),
 609                         userHandle);
 610                 final CharSequence contentDescription = mUm.getBadgedLabelForUser(entry.getLabel(),
 611                         userHandle);
 612
 613                 final String key = extractKeyFromSipper(sipper);
 614                 PowerGaugePreference pref = (PowerGaugePreference) getCachedPreference(key);
 615                 if (pref == null) {
 616                     pref = new PowerGaugePreference(getPrefContext(), badgedIcon,
 617                             contentDescription, entry);
 618                     pref.setKey(key);
 619                 }
 620
 621                 final double percentOfMax = (sipper.totalPowerMah * 100)
 622                         / mStatsHelper.getMaxPower();
 623                 sipper.percent = percentOfTotal;
 624                 pref.setTitle(entry.getLabel());
 625                 pref.setOrder(i + 1);
 626                 pref.setPercent(percentOfTotal);
 627                 pref.shouldShowAnomalyIcon(mAnomalySparseArray.get(sipper.getUid()) != null);
 628                 if (sipper.usageTimeMs == 0 && sipper.drainType == DrainType.APP) {
 629                     sipper.usageTimeMs = mBatteryUtils.getProcessTimeMs(
 630                             BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, mStatsType);
 631                 }
 632                 setUsageSummary(pref, sipper.usageTimeMs);
 633                 if ((sipper.drainType != DrainType.APP
 634                         || sipper.uidObj.getUid() == Process.ROOT_UID)
 635                         && sipper.drainType != DrainType.USER) {
 636                     pref.setTint(colorControl);
 637                 }
 638                 addedSome = true;
 639                 mAppListGroup.addPreference(pref);
 640                 if (mAppListGroup.getPreferenceCount() - getCachedCount()
 641                         > (MAX_ITEMS_TO_LIST + 1)) {
 642                     break;
 643                 }
 644             }
 645         }
 646         if (!addedSome) {
 647             addNotAvailableMessage();
 648         }
 649         removeCachedPrefs(mAppListGroup);
 650
 651         BatteryEntry.startRequestQueue();
 652     }
 653
 654     @VisibleForTesting
 655     void initAnomalyDetectionIfPossible() {
 656         if (mPowerFeatureProvider.isAnomalyDetectionEnabled()) {
 657             getLoaderManager().initLoader(ANOMALY_LOADER, Bundle.EMPTY, mAnomalyLoaderCallbacks);
 658         }
 659     }
 660
 661     @VisibleForTesting
 662     BatterySipper findBatterySipperByType(List<BatterySipper> usageList, DrainType type) {
 663         for (int i = 0, size = usageList.size(); i < size; i++) {
 664             final BatterySipper sipper = usageList.get(i);
 665             if (sipper.drainType == type) {
 666                 return sipper;
 667             }
 668         }
 669         return null;
 670     }
 671
 672     @VisibleForTesting
 673     void updateScreenPreference() {
 674         final BatterySipper sipper = findBatterySipperByType(
 675                 mStatsHelper.getUsageList(), DrainType.SCREEN);
 676         final long usageTimeMs = sipper != null ? sipper.usageTimeMs : 0;
 677
 678         mScreenUsagePref.setSubtitle(Utils.formatElapsedTime(getContext(), usageTimeMs, false));
 679     }
 680
 681     @VisibleForTesting
 682     void updateLastFullChargePreference(long timeMs) {
 683         final CharSequence timeSequence = Utils.formatElapsedTime(getContext(), timeMs, false);
 684         mLastFullChargePref.setSubtitle(
 685                 TextUtils.expandTemplate(getText(R.string.power_last_full_charge_summary),
 686                         timeSequence));
 687     }
 688
 689     @VisibleForTesting
 690     long calculateRunningTimeBasedOnStatsType() {
 691         final long elapsedRealtimeUs = SystemClock.elapsedRealtime() * 1000;
 692         // Return the battery time (millisecond) on status mStatsType
 693         return mStatsHelper.getStats().computeBatteryRealtime(elapsedRealtimeUs,
 694                 mStatsType /* STATS_SINCE_CHARGED */) / 1000;
 695     }
 696
 697     @VisibleForTesting
 698     void updateHeaderPreference(BatteryInfo info) {
 699         final Context context = getContext();
 700         if (context == null) {
 701             return;
 702         }
 703         final BatteryMeterView batteryView = (BatteryMeterView) mBatteryLayoutPref
 704                 .findViewById(R.id.battery_header_icon);
 705         final TextView timeText = (TextView) mBatteryLayoutPref.findViewById(R.id.battery_percent);
 706         final TextView summary1 = (TextView) mBatteryLayoutPref.findViewById(R.id.summary1);
 707         if (info.remainingLabel == null ) {
 708             summary1.setText(info.statusLabel);
 709         } else {
 710             summary1.setText(info.remainingLabel);
 711         }
 712         batteryView.setCharging(!info.discharging);
 713         startBatteryHeaderAnimationIfNecessary(batteryView, timeText, mBatteryLevel,
 714                 info.batteryLevel);
 715     }
 716
 717     @VisibleForTesting
 718     void initHeaderPreference() {
 719         final BatteryMeterView batteryView = (BatteryMeterView) mBatteryLayoutPref
 720                 .findViewById(R.id.battery_header_icon);
 721         final TextView timeText = (TextView) mBatteryLayoutPref.findViewById(R.id.battery_percent);
 722
 723         batteryView.setBatteryLevel(mBatteryLevel);
 724         timeText.setText(Utils.formatPercentage(mBatteryLevel));
 725     }
 726
 727     @VisibleForTesting
 728     void startBatteryHeaderAnimationIfNecessary(BatteryMeterView batteryView, TextView timeTextView,
 729             int prevLevel, int currentLevel) {
 730         mBatteryLevel = currentLevel;
 731         final int diff = Math.abs(prevLevel - currentLevel);
 732         if (diff != 0) {
 733             final ValueAnimator animator = ValueAnimator.ofInt(prevLevel, currentLevel);
 734             animator.setDuration(BATTERY_ANIMATION_DURATION_MS_PER_LEVEL * diff);
 735             animator.setInterpolator(AnimationUtils.loadInterpolator(getContext(),
 736                     android.R.interpolator.fast_out_slow_in));
 737             animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
 738                 @Override
 739                 public void onAnimationUpdate(ValueAnimator animation) {
 740                     final Integer level = (Integer) animation.getAnimatedValue();
 741                     batteryView.setBatteryLevel(level);
 742                     timeTextView.setText(Utils.formatPercentage(level));
 743                 }
 744             });
 745             animator.start();
 746         }
 747     }
 748
 749     @VisibleForTesting
 750     double calculatePercentage(double powerUsage, double dischargeAmount) {
 751         final double totalPower = mStatsHelper.getTotalPower();
 752         return totalPower == 0 ? 0 :
 753                 ((powerUsage / totalPower) * dischargeAmount);
 754     }
 755
 756     @VisibleForTesting
 757     void setUsageSummary(Preference preference, long usageTimeMs) {
 758         // Only show summary when usage time is longer than one minute
 759         if (usageTimeMs >= DateUtils.MINUTE_IN_MILLIS) {
 760             final CharSequence timeSequence = Utils.formatElapsedTime(getContext(), usageTimeMs,
 761                     false);
 762             preference.setSummary(
 763                     TextUtils.expandTemplate(getText(R.string.battery_used_for), timeSequence));
 764         }
 765     }
 766
 767     @VisibleForTesting
 768     String extractKeyFromSipper(BatterySipper sipper) {
 769         if (sipper.uidObj != null) {
 770             return Integer.toString(sipper.getUid());
 771         } else if (sipper.drainType != DrainType.APP) {
 772             return sipper.drainType.toString();
 773         } else if (sipper.getPackages() != null) {
 774             return TextUtils.concat(sipper.getPackages()).toString();
 775         } else {
 776             Log.w(TAG, "Inappropriate BatterySipper without uid and package names: " + sipper);
 777             return "-1";
 778         }
 779     }
 780
 781     @VisibleForTesting
 782     void setBatteryLayoutPreference(LayoutPreference layoutPreference) {
 783         mBatteryLayoutPref = layoutPreference;
 784     }
 785
 786     @VisibleForTesting
 787     void initFeatureProvider() {
 788         final Context context = getContext();
 789         mPowerFeatureProvider = FeatureFactory.getFactory(context)
 790                 .getPowerUsageFeatureProvider(context);
 791     }
 792
 793     @VisibleForTesting
 794     void updateAnomalySparseArray(List<Anomaly> anomalies) {
 795         mAnomalySparseArray.clear();
 796         for (int i = 0, size = anomalies.size(); i < size; i++) {
 797             final Anomaly anomaly = anomalies.get(i);
 798             if (mAnomalySparseArray.get(anomaly.uid) == null) {
 799                 mAnomalySparseArray.append(anomaly.uid, new ArrayList<>());
 800             }
 801             mAnomalySparseArray.get(anomaly.uid).add(anomaly);
 802         }
 803     }
 804
 805     @VisibleForTesting
 806     void useEnhancedEstimateIfAvailable(Context context, BatteryInfo batteryInfo) {
 807         if (mEnhancedEstimate > 0
 808                 && mPowerFeatureProvider.isEnhancedBatteryPredictionEnabled(context)) {
 809             final Resources resources = context.getResources();
 810             batteryInfo.remainingTimeUs = mEnhancedEstimate;
 811             String timeString = Formatter.formatShortElapsedTime(context, mEnhancedEstimate);
 812             batteryInfo.remainingLabel = resources.getString(
 813                     com.android.settingslib.R.string.power_remaining_duration_only,
 814                     timeString);
 815         }
 816     }
 817
 818     private static List<BatterySipper> getFakeStats() {
 819         ArrayList<BatterySipper> stats = new ArrayList<>();
 820         float use = 5;
 821         for (DrainType type : DrainType.values()) {
 822             if (type == DrainType.APP) {
 823                 continue;
 824             }
 825             stats.add(new BatterySipper(type, null, use));
 826             use += 5;
 827         }
 828         for (int i = 0; i < 100; i++) {
 829             stats.add(new BatterySipper(DrainType.APP,
 830                     new FakeUid(Process.FIRST_APPLICATION_UID + i), use));
 831         }
 832         stats.add(new BatterySipper(DrainType.APP,
 833                 new FakeUid(0), use));
 834
 835         // Simulate dex2oat process.
 836         BatterySipper sipper = new BatterySipper(DrainType.APP,
 837                 new FakeUid(UserHandle.getSharedAppGid(Process.FIRST_APPLICATION_UID)), 10.0f);
 838         sipper.packageWithHighestDrain = "dex2oat";
 839         stats.add(sipper);
 840
 841         sipper = new BatterySipper(DrainType.APP,
 842                 new FakeUid(UserHandle.getSharedAppGid(Process.FIRST_APPLICATION_UID + 1)), 10.0f);
 843         sipper.packageWithHighestDrain = "dex2oat";
 844         stats.add(sipper);
 845
 846         sipper = new BatterySipper(DrainType.APP,
 847                 new FakeUid(UserHandle.getSharedAppGid(Process.LOG_UID)), 9.0f);
 848         stats.add(sipper);
 849
 850         return stats;
 851     }
 852
 853     Handler mHandler = new Handler() {
 854
 855         @Override
 856         public void handleMessage(Message msg) {
 857             switch (msg.what) {
 858                 case BatteryEntry.MSG_UPDATE_NAME_ICON:
 859                     BatteryEntry entry = (BatteryEntry) msg.obj;
 860                     PowerGaugePreference pgp =
 861                             (PowerGaugePreference) findPreference(
 862                                     Integer.toString(entry.sipper.uidObj.getUid()));
 863                     if (pgp != null) {
 864                         final int userId = UserHandle.getUserId(entry.sipper.getUid());
 865                         final UserHandle userHandle = new UserHandle(userId);
 866                         pgp.setIcon(mUm.getBadgedIconForUser(entry.getIcon(), userHandle));
 867                         pgp.setTitle(entry.name);
 868                         if (entry.sipper.drainType == DrainType.APP) {
 869                             pgp.setContentDescription(entry.name);
 870                         }
 871                     }
 872                     break;
 873                 case BatteryEntry.MSG_REPORT_FULLY_DRAWN:
 874                     Activity activity = getActivity();
 875                     if (activity != null) {
 876                         activity.reportFullyDrawn();
 877                     }
 878                     break;
 879             }
 880             super.handleMessage(msg);
 881         }
 882     };
 883
 884     @Override
 885     public void onAnomalyHandled(Anomaly anomaly) {
 886         mAnomalySummaryPreferenceController.hideHighUsagePreference();
 887     }
 888
 889     private static class SummaryProvider implements SummaryLoader.SummaryProvider {
 890         private final Context mContext;
 891         private final SummaryLoader mLoader;
 892         private final BatteryBroadcastReceiver mBatteryBroadcastReceiver;
 893
 894         private SummaryProvider(Context context, SummaryLoader loader) {
 895             mContext = context;
 896             mLoader = loader;
 897             mBatteryBroadcastReceiver = new BatteryBroadcastReceiver(mContext);
 898             mBatteryBroadcastReceiver.setBatteryChangedListener(() -> {
 899                 BatteryInfo.getBatteryInfo(mContext, new BatteryInfo.Callback() {
 900                     @Override
 901                     public void onBatteryInfoLoaded(BatteryInfo info) {
 902                         mLoader.setSummary(SummaryProvider.this, info.chargeLabelString);
 903                     }
 904                 });
 905             });
 906         }
 907
 908         @Override
 909         public void setListening(boolean listening) {
 910             if (listening) {
 911                 mBatteryBroadcastReceiver.register();
 912             } else {
 913                 mBatteryBroadcastReceiver.unRegister();
 914             }
 915         }
 916     }
 917
 918     public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 919             new BaseSearchIndexProvider() {
 920                 @Override
 921                 public List<SearchIndexableResource> getXmlResourcesToIndex(
 922                         Context context, boolean enabled) {
 923                     final SearchIndexableResource sir = new SearchIndexableResource(context);
 924                     sir.xmlResId = R.xml.power_usage_summary;
 925                     return Arrays.asList(sir);
 926                 }
 927
 928                 @Override
 929                 public List<String> getNonIndexableKeys(Context context) {
 930                     List<String> niks = new ArrayList<>();
 931                     // Duplicates in display
 932                     niks.add(KEY_AUTO_BRIGHTNESS);
 933                     niks.add(KEY_SCREEN_TIMEOUT);
 934                     niks.add(KEY_BATTERY_SAVER_SUMMARY);
 935                     return niks;
 936                 }
 937             };
 938
 939     public static final SummaryLoader.SummaryProviderFactory SUMMARY_PROVIDER_FACTORY
 940             = new SummaryLoader.SummaryProviderFactory() {
 941         @Override
 942         public SummaryLoader.SummaryProvider createSummaryProvider(Activity activity,
 943                 SummaryLoader summaryLoader) {
 944             return new SummaryProvider(activity, summaryLoader);
 945         }
 946     };
 947 }