Transition HighUsageDetector to BatteryUsageStats API

Bug: 173745486
Test: make RunSettingsRoboTests
Test: male RunSettingsGoogleRoboTests

Change-Id: Ie8f90a67e4dd16fa67cf4f44a3678a789b3da18a

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

@@ -42,7 +42,6 @@ import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.annotation.WorkerThread;
 
-import com.android.internal.os.BatterySipper;
 import com.android.internal.os.BatteryStatsHelper;
 import com.android.internal.util.ArrayUtils;
 import com.android.settings.fuelgauge.batterytip.AnomalyDatabaseHelper;
@@ -173,22 +172,12 @@ public class BatteryUtils {
     }
 
     /**
-     * Check whether we should hide the battery sipper.
+     * Returns true if the specified battery consumer should be excluded from the summary
+     * battery consumption list.
      */
-    public boolean shouldHideSipper(BatterySipper sipper) {
+    public boolean shouldHideUidBatteryConsumer(UidBatteryConsumer consumer) {
-        final BatterySipper.DrainType drainType = sipper.drainType;
+        return shouldHideUidBatteryConsumer(consumer,
-
+                mPackageManager.getPackagesForUid(consumer.getUid()));
-        return drainType == BatterySipper.DrainType.IDLE
-                || drainType == BatterySipper.DrainType.CELL
-                || drainType == BatterySipper.DrainType.SCREEN
-                || drainType == BatterySipper.DrainType.UNACCOUNTED
-                || drainType == BatterySipper.DrainType.OVERCOUNTED
-                || drainType == BatterySipper.DrainType.BLUETOOTH
-                || drainType == BatterySipper.DrainType.WIFI
-                || (sipper.totalPowerMah * SECONDS_IN_HOUR) < MIN_POWER_THRESHOLD_MILLI_AMP
-                || mPowerUsageFeatureProvider.isTypeService(sipper)
-                || mPowerUsageFeatureProvider.isTypeSystem(sipper)
-                || isHiddenSystemModule(sipper);
     }
 
     /**
@@ -227,17 +216,6 @@ public class BatteryUtils {
         }
     }
 
-    /**
-     * Return {@code true} if one of packages in {@code sipper} is hidden system modules
-     */
-    public boolean isHiddenSystemModule(BatterySipper sipper) {
-        if (sipper.uidObj == null) {
-            return false;
-        }
-        sipper.mPackages = mPackageManager.getPackagesForUid(sipper.getUid());
-        return isHiddenSystemModule(sipper.mPackages);
-    }
-
     /**
      * Returns true if one the specified packages belongs to a hidden system module.
      */
@@ -270,23 +248,6 @@ public class BatteryUtils {
         return (powerUsageMah / totalPowerMah) * dischargeAmount;
     }
 
-    /**
-     * Calculate the whole running time in the state {@code statsType}
-     *
-     * @param batteryStatsHelper utility class that contains the data
-     * @param statsType          state that we want to calculate the time for
-     * @return the running time in millis
-     */
-    public long calculateRunningTimeBasedOnStatsType(BatteryStatsHelper batteryStatsHelper,
-            int statsType) {
-        final long elapsedRealtimeUs = PowerUtil.convertMsToUs(
-                SystemClock.elapsedRealtime());
-        // Return the battery time (millisecond) on status mStatsType
-        return PowerUtil.convertUsToMs(
-                batteryStatsHelper.getStats().computeBatteryRealtime(elapsedRealtimeUs, statsType));
-
-    }
-
     /**
      * Find the package name for a {@link android.os.BatteryStats.Uid}
      *
@@ -336,14 +297,13 @@ public class BatteryUtils {
     /**
      * Calculate the time since last full charge, including the device off time
      *
-     * @param batteryStatsHelper utility class that contains the data
+     * @param batteryUsageStats  class that contains the data
      * @param currentTimeMs      current wall time
      * @return time in millis
      */
-    public long calculateLastFullChargeTime(BatteryStatsHelper batteryStatsHelper,
+    public long calculateLastFullChargeTime(BatteryUsageStats batteryUsageStats,
             long currentTimeMs) {
-        return currentTimeMs - batteryStatsHelper.getStats().getStartClockTime();
+        return currentTimeMs - batteryUsageStats.getStatsStartRealtime();
-
     }
 
     public static void logRuntime(String tag, String message, long startTime) {

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

@@ -108,7 +108,7 @@ public class PowerUsageSummary extends PowerUsageBase implements
 
                 @Override
                 public Loader<List<BatteryTip>> onCreateLoader(int id, Bundle args) {
-                    return new BatteryTipLoader(getContext(), mStatsHelper);
+                    return new BatteryTipLoader(getContext(), mBatteryUsageStats);
                 }
 
                 @Override

src/com/android/settings/fuelgauge/batterytip/BatteryTipLoader.java

@@ -17,10 +17,10 @@
 package com.android.settings.fuelgauge.batterytip;
 
 import android.content.Context;
+import android.os.BatteryUsageStats;
 
 import androidx.annotation.VisibleForTesting;
 
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.fuelgauge.BatteryInfo;
 import com.android.settings.fuelgauge.BatteryUtils;
 import com.android.settings.fuelgauge.batterytip.detectors.BatteryDefenderDetector;
@@ -48,13 +48,13 @@ public class BatteryTipLoader extends AsyncLoaderCompat<List<BatteryTip>> {
 
     private static final boolean USE_FAKE_DATA = false;
 
-    private BatteryStatsHelper mBatteryStatsHelper;
+    private BatteryUsageStats mBatteryUsageStats;
     @VisibleForTesting
     BatteryUtils mBatteryUtils;
 
-    public BatteryTipLoader(Context context, BatteryStatsHelper batteryStatsHelper) {
+    public BatteryTipLoader(Context context, BatteryUsageStats batteryUsageStats) {
         super(context);
-        mBatteryStatsHelper = batteryStatsHelper;
+        mBatteryUsageStats = batteryUsageStats;
         mBatteryUtils = BatteryUtils.getInstance(context);
     }
 
@@ -69,7 +69,7 @@ public class BatteryTipLoader extends AsyncLoaderCompat<List<BatteryTip>> {
         final Context context = getContext();
 
         tips.add(new LowBatteryDetector(context, policy, batteryInfo).detect());
-        tips.add(new HighUsageDetector(context, policy, mBatteryStatsHelper, batteryInfo).detect());
+        tips.add(new HighUsageDetector(context, policy, mBatteryUsageStats, batteryInfo).detect());
         tips.add(new SmartBatteryDetector(policy, context.getContentResolver()).detect());
         tips.add(new EarlyWarningDetector(policy, context).detect());
         tips.add(new BatteryDefenderDetector(batteryInfo).detect());

src/com/android/settings/fuelgauge/batterytip/detectors/HighUsageDetector.java

@@ -19,12 +19,11 @@ package com.android.settings.fuelgauge.batterytip.detectors;
 import static com.android.settings.Utils.SETTINGS_PACKAGE_NAME;
 
 import android.content.Context;
-import android.os.BatteryStats;
+import android.os.BatteryUsageStats;
+import android.os.UidBatteryConsumer;
 
 import androidx.annotation.VisibleForTesting;
 
-import com.android.internal.os.BatterySipper;
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.fuelgauge.BatteryInfo;
 import com.android.settings.fuelgauge.BatteryUtils;
 import com.android.settings.fuelgauge.batterytip.AppInfo;
@@ -34,7 +33,6 @@ import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;
 import com.android.settings.fuelgauge.batterytip.tips.HighUsageTip;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
@@ -44,7 +42,7 @@ import java.util.concurrent.TimeUnit;
  */
 public class HighUsageDetector implements BatteryTipDetector {
     private BatteryTipPolicy mPolicy;
-    private BatteryStatsHelper mBatteryStatsHelper;
+    private BatteryUsageStats mBatteryUsageStats;
     private final BatteryInfo mBatteryInfo;
     private List<AppInfo> mHighUsageAppList;
     @VisibleForTesting
@@ -55,9 +53,9 @@ public class HighUsageDetector implements BatteryTipDetector {
     boolean mDischarging;
 
     public HighUsageDetector(Context context, BatteryTipPolicy policy,
-            BatteryStatsHelper batteryStatsHelper, BatteryInfo batteryInfo) {
+            BatteryUsageStats batteryUsageStats, BatteryInfo batteryInfo) {
         mPolicy = policy;
-        mBatteryStatsHelper = batteryStatsHelper;
+        mBatteryUsageStats = batteryUsageStats;
         mBatteryInfo = batteryInfo;
         mHighUsageAppList = new ArrayList<>();
         mBatteryUtils = BatteryUtils.getInstance(context);
@@ -69,37 +67,35 @@ public class HighUsageDetector implements BatteryTipDetector {
     @Override
     public BatteryTip detect() {
         final long lastFullChargeTimeMs = mBatteryUtils.calculateLastFullChargeTime(
-                mBatteryStatsHelper, System.currentTimeMillis());
+                mBatteryUsageStats, System.currentTimeMillis());
         if (mPolicy.highUsageEnabled && mDischarging) {
             parseBatteryData();
             if (mDataParser.isDeviceHeavilyUsed() || mPolicy.testHighUsageTip) {
-                final BatteryStats batteryStats = mBatteryStatsHelper.getStats();
+                final double totalPower = mBatteryUsageStats.getConsumedPower();
-                final List<BatterySipper> batterySippers
+                final int dischargeAmount = mBatteryUsageStats.getDischargePercentage();
-                        = new ArrayList<>(mBatteryStatsHelper.getUsageList());
+                final List<UidBatteryConsumer> uidBatteryConsumers =
-                final double totalPower = mBatteryStatsHelper.getTotalPower();
+                        mBatteryUsageStats.getUidBatteryConsumers();
-                final int dischargeAmount = batteryStats != null
+                // Sort by descending power
-                        ? batteryStats.getDischargeAmount(BatteryStats.STATS_SINCE_CHARGED)
+                uidBatteryConsumers.sort(
-                        : 0;
+                        (consumer1, consumer2) -> Double.compare(consumer2.getConsumedPower(),
-
+                                consumer1.getConsumedPower()));
-                Collections.sort(batterySippers,
+                for (UidBatteryConsumer consumer : uidBatteryConsumers) {
-                        (sipper1, sipper2) -> Double.compare(sipper2.totalSmearedPowerMah,
-                                sipper1.totalSmearedPowerMah));
-                for (BatterySipper batterySipper : batterySippers) {
                     final double percent = mBatteryUtils.calculateBatteryPercent(
-                            batterySipper.totalSmearedPowerMah, totalPower, dischargeAmount);
+                            consumer.getConsumedPower(), totalPower, dischargeAmount);
-                    if ((percent + 0.5f < 1f) || mBatteryUtils.shouldHideSipper(batterySipper)) {
+                    if ((percent + 0.5f < 1f)
+                            || mBatteryUtils.shouldHideUidBatteryConsumer(consumer)) {
                         // Don't show it if we should hide or usage percentage is lower than 1%
                         continue;
                     }
+
                     mHighUsageAppList.add(new AppInfo.Builder()
-                            .setUid(batterySipper.getUid())
+                            .setUid(consumer.getUid())
                             .setPackageName(
-                                    mBatteryUtils.getPackageName(batterySipper.getUid()))
+                                    mBatteryUtils.getPackageName(consumer.getUid()))
                             .build());
                     if (mHighUsageAppList.size() >= mPolicy.highUsageAppCount) {
                         break;
                     }
-
                 }
 
                 // When in test mode, add an app if necessary

src/com/android/settings/homepage/contextualcards/slices/BatteryFixSlice.java

@@ -29,6 +29,7 @@ import android.graphics.PorterDuff;
 import android.graphics.PorterDuffColorFilter;
 import android.graphics.drawable.Drawable;
 import android.net.Uri;
+import android.os.BatteryUsageStats;
 import android.util.ArrayMap;
 import android.view.View;
 
@@ -40,11 +41,10 @@ import androidx.slice.builders.ListBuilder;
 import androidx.slice.builders.ListBuilder.RowBuilder;
 import androidx.slice.builders.SliceAction;
 
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.R;
 import com.android.settings.SubSettings;
 import com.android.settings.Utils;
-import com.android.settings.fuelgauge.BatteryStatsHelperLoader;
+import com.android.settings.fuelgauge.BatteryUsageStatsLoader;
 import com.android.settings.fuelgauge.PowerUsageSummary;
 import com.android.settings.fuelgauge.batterytip.BatteryTipLoader;
 import com.android.settings.fuelgauge.batterytip.BatteryTipPreferenceController;
@@ -206,9 +206,10 @@ public class BatteryFixSlice implements CustomSliceable {
     @WorkerThread
     @VisibleForTesting
     static List<BatteryTip> refreshBatteryTips(Context context) {
-        final BatteryStatsHelperLoader statsLoader = new BatteryStatsHelperLoader(context);
+        final BatteryUsageStatsLoader statsLoader = new BatteryUsageStatsLoader(context,
-        final BatteryStatsHelper statsHelper = statsLoader.loadInBackground();
+                /* includeBatteryHistory */ false);
-        final BatteryTipLoader loader = new BatteryTipLoader(context, statsHelper);
+        final BatteryUsageStats batteryUsageStats = statsLoader.loadInBackground();
+        final BatteryTipLoader loader = new BatteryTipLoader(context, batteryUsageStats);
         final List<BatteryTip> batteryTips = loader.loadInBackground();
         for (BatteryTip batteryTip : batteryTips) {
             if (batteryTip.getState() != BatteryTip.StateType.INVISIBLE) {

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

@@ -46,6 +46,7 @@ import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.os.BatteryStats;
 import android.os.BatteryStatsManager;
+import android.os.BatteryUsageStats;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Process;
@@ -120,6 +121,8 @@ public class BatteryUtilsTest {
     @Mock
     private BatteryStats.Timer mTimer;
     @Mock
+    private BatteryUsageStats mBatteryUsageStats;
+    @Mock
     private SystemBatteryConsumer mSystemBatteryConsumer;
     @Mock
     private BatterySipper mNormalBatterySipper;
@@ -336,81 +339,6 @@ public class BatteryUtilsTest {
         assertThat(mBatteryUtils.shouldHideSystemBatteryConsumer(mSystemBatteryConsumer)).isFalse();
     }
 
-    @Test
-    public void testShouldHideSipper_TypeUnAccounted_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.UNACCOUNTED;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeOverAccounted_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.OVERCOUNTED;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeIdle_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.IDLE;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeCell_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.CELL;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeScreen_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.SCREEN;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeWifi_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.WIFI;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeBluetooth_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.BLUETOOTH;
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeSystem_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
-        when(mNormalBatterySipper.getUid()).thenReturn(Process.ROOT_UID);
-        when(mProvider.isTypeSystem(any())).thenReturn(true);
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_UidNormal_ReturnFalse() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
-        when(mNormalBatterySipper.getUid()).thenReturn(UID);
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isFalse();
-    }
-
-    @Test
-    public void testShouldHideSipper_TypeService_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
-        when(mNormalBatterySipper.getUid()).thenReturn(UID);
-        when(mProvider.isTypeService(any())).thenReturn(true);
-
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
-    @Test
-    public void testShouldHideSipper_hiddenSystemModule_ReturnTrue() {
-        mNormalBatterySipper.drainType = BatterySipper.DrainType.APP;
-        when(mNormalBatterySipper.getUid()).thenReturn(UID);
-        when(mBatteryUtils.isHiddenSystemModule(mNormalBatterySipper)).thenReturn(true);
-
-        assertThat(mBatteryUtils.shouldHideSipper(mNormalBatterySipper)).isTrue();
-    }
-
     @Test
     public void testCalculateBatteryPercent() {
         assertThat(mBatteryUtils.calculateBatteryPercent(BATTERY_SYSTEM_USAGE, TOTAL_BATTERY_USAGE,
@@ -418,20 +346,14 @@ public class BatteryUtilsTest {
                 .isWithin(PRECISION).of(PERCENT_SYSTEM_USAGE);
     }
 
-    @Test
-    public void testCalculateRunningTimeBasedOnStatsType() {
-        assertThat(mBatteryUtils.calculateRunningTimeBasedOnStatsType(mBatteryStatsHelper,
-                BatteryStats.STATS_SINCE_CHARGED)).isEqualTo(TIME_SINCE_LAST_FULL_CHARGE_MS);
-    }
-
     @Test
     public void testCalculateLastFullChargeTime() {
         final long currentTimeMs = System.currentTimeMillis();
-        when(mBatteryStatsHelper.getStats().getStartClockTime()).thenReturn(
+        when(mBatteryUsageStats.getStatsStartRealtime()).thenReturn(
                 currentTimeMs - TIME_SINCE_LAST_FULL_CHARGE_MS);
 
-        assertThat(mBatteryUtils.calculateLastFullChargeTime(
+        assertThat(mBatteryUtils.calculateLastFullChargeTime(mBatteryUsageStats, currentTimeMs))
-                mBatteryStatsHelper, currentTimeMs)).isEqualTo(TIME_SINCE_LAST_FULL_CHARGE_MS);
+                .isEqualTo(TIME_SINCE_LAST_FULL_CHARGE_MS);
     }
 
     @Test

tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipLoaderTest.java

@@ -24,9 +24,9 @@ import static org.mockito.Mockito.spy;
 
 import android.content.Context;
 import android.content.Intent;
+import android.os.BatteryUsageStats;
 import android.os.PowerManager;
 
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.fuelgauge.BatteryInfo;
 import com.android.settings.fuelgauge.BatteryUtils;
 import com.android.settings.fuelgauge.batterytip.tips.AppLabelPredicate;
@@ -57,7 +57,7 @@ public class BatteryTipLoaderTest {
             BatteryTip.TipType.SUMMARY,
             BatteryTip.TipType.SMART_BATTERY_MANAGER};
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    private BatteryStatsHelper mBatteryStatsHelper;
+    private BatteryUsageStats mBatteryUsageStats;
     @Mock
     private PowerManager mPowerManager;
     @Mock
@@ -78,7 +78,7 @@ public class BatteryTipLoaderTest {
         doReturn(mPowerManager).when(mContext).getSystemService(Context.POWER_SERVICE);
         doReturn(mIntent).when(mContext).registerReceiver(any(), any());
         doReturn(mBatteryInfo).when(mBatteryUtils).getBatteryInfo(any());
-        mBatteryTipLoader = new BatteryTipLoader(mContext, mBatteryStatsHelper);
+        mBatteryTipLoader = new BatteryTipLoader(mContext, mBatteryUsageStats);
         mBatteryTipLoader.mBatteryUtils = mBatteryUtils;
     }
 

tests/robotests/src/com/android/settings/fuelgauge/batterytip/detectors/HighUsageDetectorTest.java

@@ -19,23 +19,20 @@ package com.android.settings.fuelgauge.batterytip.detectors;
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.content.Intent;
-import android.os.BatteryStats;
+import android.os.BatteryManager;
 import android.os.BatteryStatsManager;
 import android.os.BatteryUsageStats;
 import android.os.BatteryUsageStatsQuery;
+import android.os.UidBatteryConsumer;
 
-import com.android.internal.os.BatterySipper;
-import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.fuelgauge.BatteryUtils;
 import com.android.settings.fuelgauge.batterytip.AppInfo;
 import com.android.settings.fuelgauge.batterytip.BatteryTipPolicy;
@@ -46,7 +43,6 @@ import com.android.settings.fuelgauge.batterytip.tips.HighUsageTip;
 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.RobolectricTestRunner;
@@ -64,15 +60,14 @@ public class HighUsageDetectorTest {
     private static final int UID_LOW = 345;
     private static final double POWER_HIGH = 20000;
     private static final double POWER_LOW = 10000;
+
     private Context mContext;
-    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    private BatteryStatsHelper mBatteryStatsHelper;
     @Mock
-    private BatterySipper mHighBatterySipper;
+    private UidBatteryConsumer mHighBatteryConsumer;
     @Mock
-    private BatterySipper mLowBatterySipper;
+    private UidBatteryConsumer mLowBatteryConsumer;
     @Mock
-    private BatterySipper mSystemBatterySipper;
+    private UidBatteryConsumer mSystemBatteryConsumer;
     @Mock
     private HighUsageDataParser mDataParser;
     @Mock
@@ -85,7 +80,6 @@ public class HighUsageDetectorTest {
     private BatteryTipPolicy mPolicy;
     private BatteryUtils mBatteryUtils;
     private HighUsageDetector mHighUsageDetector;
-    private List<BatterySipper> mUsageList;
 
     @Before
     public void setUp() {
@@ -100,27 +94,22 @@ public class HighUsageDetectorTest {
         when(mBatteryStatsManager.getBatteryUsageStats(any(BatteryUsageStatsQuery.class)))
                 .thenReturn(mBatteryUsageStats);
 
-        mContext.sendStickyBroadcast(new Intent(Intent.ACTION_BATTERY_CHANGED));
+        mContext.sendStickyBroadcast(new Intent(Intent.ACTION_BATTERY_CHANGED)
+                .putExtra(BatteryManager.EXTRA_PLUGGED, 0));
 
-        mHighUsageDetector = spy(new HighUsageDetector(mContext, mPolicy, mBatteryStatsHelper,
+        mHighUsageDetector = spy(new HighUsageDetector(mContext, mPolicy, mBatteryUsageStats,
                 mBatteryUtils.getBatteryInfo(TAG)));
         mHighUsageDetector.mBatteryUtils = mBatteryUtils;
         mHighUsageDetector.mDataParser = mDataParser;
         doNothing().when(mHighUsageDetector).parseBatteryData();
-        doReturn(UID_HIGH).when(mHighBatterySipper).getUid();
+        doReturn(UID_HIGH).when(mHighBatteryConsumer).getUid();
-        doReturn(UID_LOW).when(mLowBatterySipper).getUid();
+        doReturn(UID_LOW).when(mLowBatteryConsumer).getUid();
-        mHighBatterySipper.uidObj = mock(BatteryStats.Uid.class);
+        doReturn(POWER_HIGH).when(mHighBatteryConsumer).getConsumedPower();
-        mHighBatterySipper.drainType = BatterySipper.DrainType.APP;
+        doReturn(POWER_LOW).when(mLowBatteryConsumer).getConsumedPower();
-        mHighBatterySipper.totalSmearedPowerMah = POWER_HIGH;
+        doReturn(false).when(mBatteryUtils).shouldHideUidBatteryConsumer(mHighBatteryConsumer);
-        mLowBatterySipper.uidObj = mock(BatteryStats.Uid.class);
+        doReturn(false).when(mBatteryUtils).shouldHideUidBatteryConsumer(mLowBatteryConsumer);
-        mLowBatterySipper.drainType = BatterySipper.DrainType.APP;
+        when(mBatteryUsageStats.getDischargePercentage()).thenReturn(100);
-        mLowBatterySipper.totalSmearedPowerMah = POWER_LOW;
+        when(mBatteryUsageStats.getConsumedPower()).thenReturn(POWER_HIGH + POWER_LOW);
-        when(mBatteryUtils.shouldHideSipper(mSystemBatterySipper)).thenReturn(true);
-        when(mBatteryUtils.shouldHideSipper(mHighBatterySipper)).thenReturn(false);
-        when(mBatteryUtils.shouldHideSipper(mLowBatterySipper)).thenReturn(false);
-        when(mBatteryStatsHelper.getStats().getDischargeAmount(anyInt())).thenReturn(100);
-        when(mBatteryStatsHelper.getTotalPower()).thenReturn(POWER_HIGH + POWER_LOW);
-
 
         mHighAppInfo = new AppInfo.Builder()
                 .setUid(UID_HIGH)
@@ -129,11 +118,11 @@ public class HighUsageDetectorTest {
                 .setUid(UID_LOW)
                 .build();
 
-        mUsageList = new ArrayList<>();
+        ArrayList<UidBatteryConsumer> consumers = new ArrayList<>();
-        mUsageList.add(mSystemBatterySipper);
+        consumers.add(mSystemBatteryConsumer);
-        mUsageList.add(mLowBatterySipper);
+        consumers.add(mLowBatteryConsumer);
-        mUsageList.add(mHighBatterySipper);
+        consumers.add(mHighBatteryConsumer);
-        when(mBatteryStatsHelper.getUsageList()).thenReturn(mUsageList);
+        when(mBatteryUsageStats.getUidBatteryConsumers()).thenReturn(consumers);
     }
 
     @Test

tests/robotests/src/com/android/settings/homepage/contextualcards/slices/BatteryFixSliceTest.java

@@ -23,6 +23,7 @@ import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.net.Uri;
+import android.os.BatteryUsageStats;
 
 import androidx.slice.Slice;
 import androidx.slice.SliceMetadata;
@@ -32,6 +33,7 @@ import androidx.slice.widget.SliceLiveData;
 import com.android.internal.os.BatteryStatsHelper;
 import com.android.settings.R;
 import com.android.settings.fuelgauge.BatteryStatsHelperLoader;
+import com.android.settings.fuelgauge.BatteryUsageStatsLoader;
 import com.android.settings.fuelgauge.batterytip.AppInfo;
 import com.android.settings.fuelgauge.batterytip.BatteryTipLoader;
 import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;
@@ -57,7 +59,7 @@ import java.util.List;
 
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {
-        BatteryFixSliceTest.ShadowBatteryStatsHelperLoader.class,
+        BatteryFixSliceTest.ShadowBatteryUsageStatsLoader.class,
         BatteryFixSliceTest.ShadowBatteryTipLoader.class
 })
 public class BatteryFixSliceTest {
@@ -144,6 +146,15 @@ public class BatteryFixSliceTest {
         }
     }
 
+    @Implements(BatteryUsageStatsLoader.class)
+    public static class ShadowBatteryUsageStatsLoader {
+
+        @Implementation
+        protected BatteryUsageStats loadInBackground() {
+            return null;
+        }
+    }
+
     @Implements(BatteryTipLoader.class)
     public static class ShadowBatteryTipLoader {