Merge "Add batteryTimeRemaining and chargeTimeRemaining to BatteryUsageStats" into sc-dev

core/java/android/os/BatteryUsageStats.java

@@ -37,6 +37,8 @@ public final class BatteryUsageStats implements Parcelable {
     private final long mStatsStartRealtimeMs;
     private final double mDischargedPowerLowerBound;
     private final double mDischargedPowerUpperBound;
+    private final long mBatteryTimeRemainingMs;
+    private final long mChargeTimeRemainingMs;
     private final ArrayList<UidBatteryConsumer> mUidBatteryConsumers;
     private final ArrayList<SystemBatteryConsumer> mSystemBatteryConsumers;
     private final ArrayList<UserBatteryConsumer> mUserBatteryConsumers;
@@ -50,6 +52,8 @@ public final class BatteryUsageStats implements Parcelable {
         mDischargedPowerUpperBound = builder.mDischargedPowerUpperBoundMah;
         mHistoryBuffer = builder.mHistoryBuffer;
         mHistoryTagPool = builder.mHistoryTagPool;
+        mBatteryTimeRemainingMs = builder.mBatteryTimeRemainingMs;
+        mChargeTimeRemainingMs = builder.mChargeTimeRemainingMs;
 
         double totalPower = 0;
 
@@ -109,6 +113,25 @@ public final class BatteryUsageStats implements Parcelable {
         return Range.create(mDischargedPowerLowerBound, mDischargedPowerUpperBound);
     }
 
+    /**
+     * Returns an approximation for how much run time (in milliseconds) is remaining on
+     * the battery.  Returns -1 if no time can be computed: either there is not
+     * enough current data to make a decision, or the battery is currently
+     * charging.
+     */
+    public long getBatteryTimeRemainingMs() {
+        return mBatteryTimeRemainingMs;
+    }
+
+    /**
+     * Returns an approximation for how much time (in milliseconds) remains until the battery
+     * is fully charged.  Returns -1 if no time can be computed: either there is not
+     * enough current data to make a decision, or the battery is currently discharging.
+     */
+    public long getChargeTimeRemainingMs() {
+        return mChargeTimeRemainingMs;
+    }
+
     /**
      * Total amount of battery charge drained since BatteryStats reset (e.g. due to being fully
      * charged), in mAh
@@ -156,6 +179,8 @@ public final class BatteryUsageStats implements Parcelable {
         mDischargePercentage = source.readInt();
         mDischargedPowerLowerBound = source.readDouble();
         mDischargedPowerUpperBound = source.readDouble();
+        mBatteryTimeRemainingMs = source.readLong();
+        mChargeTimeRemainingMs = source.readLong();
         mUidBatteryConsumers = new ArrayList<>();
         source.readParcelableList(mUidBatteryConsumers, getClass().getClassLoader());
         mSystemBatteryConsumers = new ArrayList<>();
@@ -194,6 +219,8 @@ public final class BatteryUsageStats implements Parcelable {
         dest.writeInt(mDischargePercentage);
         dest.writeDouble(mDischargedPowerLowerBound);
         dest.writeDouble(mDischargedPowerUpperBound);
+        dest.writeLong(mBatteryTimeRemainingMs);
+        dest.writeLong(mChargeTimeRemainingMs);
         dest.writeParcelableList(mUidBatteryConsumers, flags);
         dest.writeParcelableList(mSystemBatteryConsumers, flags);
         dest.writeParcelableList(mUserBatteryConsumers, flags);
@@ -237,6 +264,8 @@ public final class BatteryUsageStats implements Parcelable {
         private int mDischargePercentage;
         private double mDischargedPowerLowerBoundMah;
         private double mDischargedPowerUpperBoundMah;
+        private long mBatteryTimeRemainingMs = -1;
+        private long mChargeTimeRemainingMs = -1;
         private final SparseArray<UidBatteryConsumer.Builder> mUidBatteryConsumerBuilders =
                 new SparseArray<>();
         private final SparseArray<SystemBatteryConsumer.Builder> mSystemBatteryConsumerBuilders =
@@ -288,6 +317,26 @@ public final class BatteryUsageStats implements Parcelable {
             return this;
         }
 
+        /**
+         * Sets an approximation for how much time (in milliseconds) remains until the battery
+         * is fully discharged.
+         */
+        @NonNull
+        public Builder setBatteryTimeRemainingMs(long batteryTimeRemainingMs) {
+            mBatteryTimeRemainingMs = batteryTimeRemainingMs;
+            return this;
+        }
+
+        /**
+         * Sets an approximation for how much time (in milliseconds) remains until the battery
+         * is fully charged.
+         */
+        @NonNull
+        public Builder setChargeTimeRemainingMs(long chargeTimeRemainingMs) {
+            mChargeTimeRemainingMs = chargeTimeRemainingMs;
+            return this;
+        }
+
         /**
          * Sets the parceled recent history.
          */

core/java/com/android/internal/os/BatteryChargeCalculator.java

@@ -27,10 +27,10 @@ import java.util.List;
 /**
  * Estimates the battery discharge amounts.
  */
-public class DischargedPowerCalculator extends PowerCalculator {
+public class BatteryChargeCalculator extends PowerCalculator {
     private final double mBatteryCapacity;
 
-    public DischargedPowerCalculator(PowerProfile powerProfile) {
+    public BatteryChargeCalculator(PowerProfile powerProfile) {
         mBatteryCapacity = powerProfile.getBatteryCapacity();
     }
 
@@ -42,6 +42,16 @@ public class DischargedPowerCalculator extends PowerCalculator {
                 .setDischargedPowerRange(
                         batteryStats.getLowDischargeAmountSinceCharge() * mBatteryCapacity / 100,
                         batteryStats.getHighDischargeAmountSinceCharge() * mBatteryCapacity / 100);
+
+        final long batteryTimeRemainingMs = batteryStats.computeBatteryTimeRemaining(rawRealtimeUs);
+        if (batteryTimeRemainingMs != -1) {
+            builder.setBatteryTimeRemainingMs(batteryTimeRemainingMs / 1000);
+        }
+
+        final long chargeTimeRemainingMs = batteryStats.computeChargeTimeRemaining(rawRealtimeUs);
+        if (chargeTimeRemainingMs != -1) {
+            builder.setChargeTimeRemainingMs(chargeTimeRemainingMs / 1000);
+        }
     }
 
     @Override

core/java/com/android/internal/os/BatteryUsageStatsProvider.java

@@ -55,7 +55,7 @@ public class BatteryUsageStatsProvider {
                 mPowerCalculators = new ArrayList<>();
 
                 // Power calculators are applied in the order of registration
-                mPowerCalculators.add(new DischargedPowerCalculator(mPowerProfile));
+                mPowerCalculators.add(new BatteryChargeCalculator(mPowerProfile));
                 mPowerCalculators.add(new CpuPowerCalculator(mPowerProfile));
                 mPowerCalculators.add(new MemoryPowerCalculator(mPowerProfile));
                 mPowerCalculators.add(new WakelockPowerCalculator(mPowerProfile));

core/tests/coretests/src/com/android/internal/os/BatteryChargeCalculatorTest.java

@@ -31,7 +31,7 @@ import org.junit.runner.RunWith;
 
 @RunWith(AndroidJUnit4.class)
 @SmallTest
-public class DischargedPowerCalculatorTest {
+public class BatteryChargeCalculatorTest {
     private static final double PRECISION = 0.00001;
 
     @Rule
@@ -40,27 +40,41 @@ public class DischargedPowerCalculatorTest {
 
     @Test
     public void testDischargeTotals() {
+        BatteryChargeCalculator calculator =
+                new BatteryChargeCalculator(mStatsRule.getPowerProfile());
+
         final BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();
 
         mStatsRule.setTime(1000, 1000);
         batteryStats.resetAllStatsCmdLocked();
         batteryStats.setNoAutoReset(true);
         batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100,
-                /* plugType */ 0, 90, 72, 3700, 3_600_000, 4_000_000, 0, 1_000_000,
+                /* plugType */ 0, 90, 72, 3700, 3_600_000, 4_000_000, 0,
-                1_000_000, 1_000_000);
+                1_000_000, 1_000_000, 1_000_000);
         batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100,
-                /* plugType */ 0, 80, 72, 3700, 2_400_000, 4_000_000, 0, 2_000_000,
+                /* plugType */ 0, 85, 72, 3700, 3_000_000, 4_000_000, 0,
-                2_000_000, 2_000_000);
+                1_500_000, 1_500_000, 1_500_000);
+        batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_DISCHARGING, 100,
+                /* plugType */ 0, 80, 72, 3700, 2_400_000, 4_000_000, 0,
+                2_000_000, 2_000_000, 2_000_000);
 
-        DischargedPowerCalculator calculator =
+        BatteryUsageStats batteryUsageStats = mStatsRule.apply(calculator);
-                new DischargedPowerCalculator(mStatsRule.getPowerProfile());
-
-        final BatteryUsageStats batteryUsageStats = mStatsRule.apply(calculator);
 
         assertThat(batteryUsageStats.getDischargePercentage()).isEqualTo(10);
         assertThat(batteryUsageStats.getDischargedPowerRange().getLower())
                 .isWithin(PRECISION).of(360.0);
         assertThat(batteryUsageStats.getDischargedPowerRange().getUpper())
                 .isWithin(PRECISION).of(400.0);
+        assertThat(batteryUsageStats.getBatteryTimeRemainingMs()).isEqualTo(8_000_000);
+        assertThat(batteryUsageStats.getChargeTimeRemainingMs()).isEqualTo(-1);
+
+        // Plug in
+        batteryStats.setBatteryStateLocked(BatteryManager.BATTERY_STATUS_CHARGING, 100,
+                BatteryManager.BATTERY_PLUGGED_USB, 80, 72, 3700, 2_400_000, 4_000_000, 100,
+                4_000_000, 4_000_000, 4_000_000);
+
+        batteryUsageStats = mStatsRule.apply(calculator);
+
+        assertThat(batteryUsageStats.getChargeTimeRemainingMs()).isEqualTo(100_000);
     }
 }

core/tests/coretests/src/com/android/internal/os/BatteryStatsTests.java

@@ -23,6 +23,7 @@ import org.junit.runners.Suite;
 @Suite.SuiteClasses({
         AmbientDisplayPowerCalculatorTest.class,
         AudioPowerCalculatorTest.class,
+        BatteryChargeCalculatorTest.class,
         BatteryStatsCpuTimesTest.class,
         BatteryStatsBackgroundStatsTest.class,
         BatteryStatsBinderCallStatsTest.class,
@@ -49,7 +50,6 @@ import org.junit.runners.Suite;
         CameraPowerCalculatorTest.class,
         CpuPowerCalculatorTest.class,
         CustomMeasuredPowerCalculatorTest.class,
-        DischargedPowerCalculatorTest.class,
         FlashlightPowerCalculatorTest.class,
         GnssPowerCalculatorTest.class,
         IdlePowerCalculatorTest.class,