Add summary for categories in battery advanced page

If the category only contains one app, show usage time, otherwise
show app with maximum usage.

Also add usage time for apps in battery settings page.

Bug: 35396770
Test: RunSettingsRoboTests
Change-Id: I43fe9c2289535be2c1b95ffded6b52b0ff099589
(cherry picked from commit 3bbaca9c7c)

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

@@ -13,22 +13,29 @@
  */
 package com.android.settings.fuelgauge;
 
+import android.app.Activity;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.os.BatteryStats;
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.UserManager;
 import android.provider.SearchIndexableResource;
 import android.support.annotation.ColorInt;
 import android.support.annotation.IntDef;
 import android.support.annotation.NonNull;
 import android.support.annotation.StringRes;
 import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.Preference;
 import android.support.v7.preference.PreferenceGroup;
+
 import com.android.internal.logging.nano.MetricsProto;
 import com.android.internal.os.BatterySipper;
 import com.android.internal.os.BatterySipper.DrainType;
 import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.R;
+import com.android.settings.Utils;
 import com.android.settings.core.PreferenceController;
 import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
 import com.android.settings.overlay.FeatureFactory;
@@ -64,6 +71,38 @@ public class PowerUsageAdvanced extends PowerUsageBase {
     private PreferenceGroup mUsageListGroup;
     private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
     private PackageManager mPackageManager;
+    private UserManager mUserManager;
+    private Map<Integer, PowerUsageData> mBatteryDataMap;
+
+    Handler mHandler = new Handler() {
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case BatteryEntry.MSG_UPDATE_NAME_ICON:
+                    final int dischargeAmount = mStatsHelper.getStats().getDischargeAmount(
+                            STATUS_TYPE);
+                    final double totalPower = mStatsHelper.getTotalPower();
+                    final BatteryEntry entry = (BatteryEntry) msg.obj;
+                    final int usageType = extractUsageType(entry.sipper);
+
+                    PowerUsageData usageData = mBatteryDataMap.get(usageType);
+                    Preference pref = findPreference(String.valueOf(usageType));
+                    if (pref != null && usageData != null) {
+                        updateUsageDataSummary(usageData, totalPower, dischargeAmount);
+                        pref.setSummary(usageData.summary);
+                    }
+                    break;
+                case BatteryEntry.MSG_REPORT_FULLY_DRAWN:
+                    Activity activity = getActivity();
+                    if (activity != null) {
+                        activity.reportFullyDrawn();
+                    }
+                    break;
+            }
+            super.handleMessage(msg);
+        }
+    };
 
     @Override
     public void onCreate(Bundle icicle) {
@@ -76,6 +115,7 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         mPowerUsageFeatureProvider = FeatureFactory.getFactory(context)
                 .getPowerUsageFeatureProvider(context);
         mPackageManager = context.getPackageManager();
+        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
     }
 
     @Override
@@ -84,6 +124,21 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         refreshStats();
     }
 
+    @Override
+    public void onPause() {
+        BatteryEntry.stopRequestQueue();
+        mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON);
+        super.onPause();
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (getActivity().isChangingConfigurations()) {
+            BatteryEntry.clearUidCache();
+        }
+    }
+
     @Override
     public int getMetricsCategory() {
         return MetricsProto.MetricsEvent.FUELGAUGE_BATTERY_HISTORY_DETAIL;
@@ -116,15 +171,19 @@ public class PowerUsageAdvanced extends PowerUsageBase {
             final PowerUsageData batteryData = dataList.get(i);
             final PowerGaugePreference pref = new PowerGaugePreference(getPrefContext());
 
+            pref.setKey(String.valueOf(batteryData.usageType));
             pref.setTitle(batteryData.titleResId);
             pref.setSummary(batteryData.summary);
             pref.setPercent(batteryData.percentage);
             mUsageListGroup.addPreference(pref);
         }
+
+        BatteryEntry.startRequestQueue();
     }
 
     @VisibleForTesting
-    @UsageType int extractUsageType(BatterySipper sipper) {
+    @UsageType
+    int extractUsageType(BatterySipper sipper) {
         final DrainType drainType = sipper.drainType;
         final int uid = sipper.getUid();
 
@@ -163,21 +222,56 @@ public class PowerUsageAdvanced extends PowerUsageBase {
             sipper.mPackages = mPackageManager.getPackagesForUid(sipper.getUid());
             final PowerUsageData usageData = batteryDataMap.get(extractUsageType(sipper));
             usageData.totalPowerMah += sipper.totalPowerMah;
+            if (sipper.drainType == DrainType.APP && sipper.usageTimeMs != 0) {
+                sipper.usageTimeMs = BatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.ALL,
+                        sipper.uidObj, STATUS_TYPE);
+            }
+            usageData.totalUsageTimeMs += sipper.usageTimeMs;
+            usageData.usageList.add(sipper);
         }
 
-        // TODO(b/35396770): add logic to extract the summary
         final List<PowerUsageData> batteryDataList = new ArrayList<>(batteryDataMap.values());
         final int dischargeAmount = statusHelper.getStats().getDischargeAmount(STATUS_TYPE);
         final double totalPower = statusHelper.getTotalPower();
         for (final PowerUsageData usageData : batteryDataList) {
             usageData.percentage = (usageData.totalPowerMah / totalPower) * dischargeAmount;
+            updateUsageDataSummary(usageData, totalPower, dischargeAmount);
         }
 
         Collections.sort(batteryDataList);
 
+        mBatteryDataMap = batteryDataMap;
         return batteryDataList;
     }
 
+    @VisibleForTesting
+    void updateUsageDataSummary(PowerUsageData usageData, double totalPower, int dischargeAmount) {
+        if (usageData.usageList.size() <= 1) {
+            usageData.summary = getString(R.string.battery_used_for,
+                    Utils.formatElapsedTime(getContext(), usageData.totalUsageTimeMs, false));
+        } else {
+            BatterySipper sipper = findBatterySipperWithMaxBatteryUsage(usageData.usageList);
+            BatteryEntry batteryEntry = new BatteryEntry(getContext(), mHandler, mUserManager,
+                    sipper);
+            final double percentage = (sipper.totalPowerMah / totalPower) * dischargeAmount;
+            usageData.summary = getString(R.string.battery_used_by,
+                    Utils.formatPercentage(percentage, true), batteryEntry.name);
+        }
+    }
+
+    @VisibleForTesting
+    BatterySipper findBatterySipperWithMaxBatteryUsage(List<BatterySipper> usageList) {
+        BatterySipper sipper = usageList.get(0);
+        for (int i = 1, size = usageList.size(); i < size; i++) {
+            final BatterySipper comparedSipper = usageList.get(i);
+            if (comparedSipper.totalPowerMah > sipper.totalPowerMah) {
+                sipper = comparedSipper;
+            }
+        }
+
+        return sipper;
+    }
+
     @VisibleForTesting
     void setPackageManager(PackageManager packageManager) {
         mPackageManager = packageManager;
@@ -221,10 +315,12 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         public String summary;
         public double percentage;
         public double totalPowerMah;
+        public long totalUsageTimeMs;
         @ColorInt
         public int iconColor;
         @UsageType
         public int usageType;
+        public List<BatterySipper> usageList;
 
         public PowerUsageData(@UsageType int usageType) {
             this(usageType, 0);
@@ -233,8 +329,10 @@ public class PowerUsageAdvanced extends PowerUsageBase {
         public PowerUsageData(@UsageType int usageType, double totalPower) {
             this.usageType = usageType;
             totalPowerMah = 0;
+            totalUsageTimeMs = 0;
             titleResId = getTitleResId(usageType);
             totalPowerMah = totalPower;
+            usageList = new ArrayList<>();
         }
 
         private int getTitleResId(@UsageType int usageType) {

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

@@ -489,6 +489,10 @@ public class PowerUsageSummary extends PowerUsageBase {
                 pref.setTitle(entry.getLabel());
                 pref.setOrder(i + 1);
                 pref.setPercent(percentOfTotal);
+                if (sipper.usageTimeMs == 0 && sipper.drainType == DrainType.APP) {
+                    sipper.usageTimeMs = BatteryUtils.getProcessTimeMs(
+                            BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, mStatsType);
+                }
                 setUsageSummary(pref, usedTime, sipper.usageTimeMs);
                 if ((sipper.drainType != DrainType.APP
                         || sipper.uidObj.getUid() == Process.ROOT_UID)

tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java

@@ -15,31 +15,40 @@
  */
 package com.android.settings.fuelgauge;
 
+import android.content.Context;
 import android.content.pm.PackageManager;
-import android.os.Process;
+
 import com.android.internal.os.BatterySipper;
 import com.android.internal.os.BatterySipper.DrainType;
 import com.android.internal.os.BatteryStatsHelper;
+import com.android.settings.R;
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.Utils;
 import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData;
 import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Set;
 
 import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.eq;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 @RunWith(SettingsRobolectricTestRunner.class)
@@ -53,9 +62,13 @@ public class PowerUsageAdvancedTest {
     private static final double TYPE_WIFI_USAGE = 0;
     private static final double TOTAL_USAGE = TYPE_APP_USAGE * 2 + TYPE_BLUETOOTH_USAGE
             + TYPE_WIFI_USAGE;
+    private static final double TOTAL_POWER = 500;
     private static final double PRECISION = 0.001;
+    private static final String STUB_STRING = "stub_string";
     @Mock
-    private BatterySipper mBatterySipper;
+    private BatterySipper mNormalBatterySipper;
+    @Mock
+    private BatterySipper mMaxBatterySipper;
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private BatteryStatsHelper mBatteryStatsHelper;
     @Mock
@@ -63,11 +76,14 @@ public class PowerUsageAdvancedTest {
     @Mock
     private PackageManager mPackageManager;
     private PowerUsageAdvanced mPowerUsageAdvanced;
+    private PowerUsageData mPowerUsageData;
+    private Context mShadowContext;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mPowerUsageAdvanced = new PowerUsageAdvanced();
+        mShadowContext = RuntimeEnvironment.application;
+        mPowerUsageAdvanced = spy(new PowerUsageAdvanced());
 
         List<BatterySipper> batterySippers = new ArrayList<>();
         batterySippers.add(new BatterySipper(DrainType.APP,
@@ -83,16 +99,24 @@ public class PowerUsageAdvancedTest {
                 DISCHARGE_AMOUNT);
         when(mBatteryStatsHelper.getUsageList()).thenReturn(batterySippers);
         when(mBatteryStatsHelper.getTotalPower()).thenReturn(TOTAL_USAGE);
+        when(mPowerUsageAdvanced.getContext()).thenReturn(mShadowContext);
+        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any(), any());
+        doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any());
         mPowerUsageAdvanced.setPackageManager(mPackageManager);
         mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
+
+        mPowerUsageData = new PowerUsageData(UsageType.APP);
+        mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
+        mMaxBatterySipper.drainType = DrainType.BLUETOOTH;
+        mNormalBatterySipper.drainType = DrainType.SCREEN;
     }
 
     @Test
     public void testExtractUsageType_TypeSystem_ReturnSystem() {
-        mBatterySipper.drainType = DrainType.APP;
+        mNormalBatterySipper.drainType = DrainType.APP;
         when(mPowerUsageFeatureProvider.isTypeSystem(any())).thenReturn(true);
 
-        assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
                 .isEqualTo(UsageType.SYSTEM);
     }
 
@@ -105,19 +129,19 @@ public class PowerUsageAdvancedTest {
 
         assertThat(drainTypes.length).isEqualTo(usageTypes.length);
         for (int i = 0, size = drainTypes.length; i < size; i++) {
-            mBatterySipper.drainType = drainTypes[i];
+            mNormalBatterySipper.drainType = drainTypes[i];
-            assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+            assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
                     .isEqualTo(usageTypes[i]);
         }
     }
 
     @Test
     public void testExtractUsageType_TypeService_ReturnService() {
-        mBatterySipper.drainType = DrainType.APP;
+        mNormalBatterySipper.drainType = DrainType.APP;
-        when(mBatterySipper.getUid()).thenReturn(FAKE_UID_1);
+        when(mNormalBatterySipper.getUid()).thenReturn(FAKE_UID_1);
         when(mPowerUsageFeatureProvider.isTypeService(any())).thenReturn(true);
 
-        assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+        assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
                 .isEqualTo(UsageType.SERVICE);
     }
 
@@ -146,6 +170,37 @@ public class PowerUsageAdvancedTest {
         }
     }
 
+    @Test
+    public void testUpdateUsageDataSummary_onlyOneApp_showUsageTime() {
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+        verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_for), any());
+    }
+
+    @Test
+    public void testUpdateUsageDataSummary_moreThanOneApp_showMaxUsageApp() {
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+        mPowerUsageData.usageList.add(mMaxBatterySipper);
+        doReturn(mMaxBatterySipper).when(mPowerUsageAdvanced).findBatterySipperWithMaxBatteryUsage(
+                mPowerUsageData.usageList);
+        final double percentage = (TYPE_BLUETOOTH_USAGE / TOTAL_POWER) * DISCHARGE_AMOUNT;
+        mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+        verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_by),
+                eq(Utils.formatPercentage(percentage, true)), any());
+    }
+
+    @Test
+    public void testFindBatterySipperWithMaxBatteryUsage_findCorrectOne() {
+        mPowerUsageData.usageList.add(mNormalBatterySipper);
+        mPowerUsageData.usageList.add(mMaxBatterySipper);
+        BatterySipper sipper = mPowerUsageAdvanced.findBatterySipperWithMaxBatteryUsage(
+                mPowerUsageData.usageList);
+
+        assertThat(sipper).isEqualTo(mMaxBatterySipper);
+    }
+
     @Test
     public void testInit_ContainsAllUsageType() {
         final int[] usageTypeSet = mPowerUsageAdvanced.mUsageTypes;