Inserts last 24 hour agrregate data into indexed usage map

Bug: 184807417
Test: make SettingsRoboTests
Test: make SettingsGoogleRoboTests
Change-Id: I7771a43baf74b36a816883dd6b6a91128f827cf4

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

@@ -19,10 +19,10 @@ import java.time.Duration;
 public final class BatteryDiffEntry {
     private static final String TAG = "BatteryDiffEntry";
 
-    public final long mForegroundUsageTimeInMs;
+    public long mForegroundUsageTimeInMs;
-    public final long mBackgroundUsageTimeInMs;
+    public long mBackgroundUsageTimeInMs;
-    public final double mConsumePower;
+    public double mConsumePower;
-    // A BatteryHistEntry corresponding to this diff usage daata.
+    // A BatteryHistEntry corresponding to this diff usage data.
     public final BatteryHistEntry mBatteryHistEntry;
 
     private double mTotalConsumePower;
@@ -51,6 +51,15 @@ public final class BatteryDiffEntry {
         return mPercentOfTotal;
     }
 
+    /** Clones a new instance. */
+    public BatteryDiffEntry clone() {
+        return new BatteryDiffEntry(
+            this.mForegroundUsageTimeInMs,
+            this.mBackgroundUsageTimeInMs,
+            this.mConsumePower,
+            this.mBatteryHistEntry /*same instance*/);
+    }
+
     @Override
     public String toString() {
         final StringBuilder builder = new StringBuilder()

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

@@ -244,9 +244,42 @@ public final class ConvertUtils {
                 diffEntry.setTotalConsumePower(totalConsumePower);
             }
         }
+        insert24HoursData(BatteryChartView.SELECTED_INDEX_ALL, resultMap);
         return resultMap;
     }
 
+    private static void insert24HoursData(
+            final int desiredIndex,
+            final Map<Integer, List<BatteryDiffEntry>> indexedUsageMap) {
+        final Map<String, BatteryDiffEntry> resultMap = new HashMap<>();
+        double totalConsumePower = 0.0;
+        // Loops for all BatteryDiffEntry and aggregate them together.
+        for (List<BatteryDiffEntry> entryList : indexedUsageMap.values()) {
+            for (BatteryDiffEntry entry : entryList) {
+                final String key = entry.mBatteryHistEntry.getKey();
+                final BatteryDiffEntry oldBatteryDiffEntry = resultMap.get(key);
+                // Creates new BatteryDiffEntry if we don't have it.
+                if (oldBatteryDiffEntry == null) {
+                    resultMap.put(key, entry.clone());
+                } else {
+                    // Sums up some fields data into the existing one.
+                    oldBatteryDiffEntry.mForegroundUsageTimeInMs +=
+                        entry.mForegroundUsageTimeInMs;
+                    oldBatteryDiffEntry.mBackgroundUsageTimeInMs +=
+                        entry.mBackgroundUsageTimeInMs;
+                    oldBatteryDiffEntry.mConsumePower += entry.mConsumePower;
+                }
+                totalConsumePower += entry.mConsumePower;
+            }
+        }
+        final List<BatteryDiffEntry> resultList = new ArrayList<>(resultMap.values());
+        // Sets total 24 hours consume power data into all BatteryDiffEntry.
+        for (BatteryDiffEntry entry : resultList) {
+            entry.setTotalConsumePower(totalConsumePower);
+        }
+        indexedUsageMap.put(Integer.valueOf(desiredIndex), resultList);
+    }
+
     private static long getDiffValue(long v1, long v2, long v3) {
         return (v2 > v1 ? v2 - v1 : 0) + (v3 > v2 ? v3 - v2 : 0);
     }
@@ -261,10 +294,11 @@ public final class ConvertUtils {
             BatteryHistEntry entry3) {
         if (entry1 != null && entry1 != EMPTY_BATTERY_HIST_ENTRY) {
             return entry1;
-        }
+        } else if (entry2 != null && entry2 != EMPTY_BATTERY_HIST_ENTRY) {
-        if (entry2 != null && entry2 != EMPTY_BATTERY_HIST_ENTRY) {
             return entry2;
-        }
+        } else {
-        return entry3 != null && entry3 != EMPTY_BATTERY_HIST_ENTRY ? entry3 : null;
+            return entry3 != null && entry3 != EMPTY_BATTERY_HIST_ENTRY
+                ? entry3 : null;
+        }
     }
 }

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

@@ -36,4 +36,17 @@ public final class BatteryDiffEntryTest {
 
         assertThat(entry.getPercentOfTotal()).isEqualTo(22.0);
     }
+
+    @Test
+    public void testSetTotalConsumePower_setZeroValue_returnsZeroValue() {
+        final BatteryDiffEntry entry =
+            new BatteryDiffEntry(
+                /*foregroundUsageTimeInMs=*/ 10001L,
+                /*backgroundUsageTimeInMs=*/ 20002L,
+                /*consumePower=*/ 22.0,
+                /*batteryHistEntry=*/ null);
+        entry.setTotalConsumePower(0);
+
+        assertThat(entry.getPercentOfTotal()).isEqualTo(0);
+    }
 }

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

@@ -210,17 +210,23 @@ public final class ConvertUtilsTest {
             ConvertUtils.getIndexedUsageMap(
                 timeSlotSize, batteryHistoryKeys, batteryHistoryMap);
 
-        assertThat(resultMap).hasSize(2);
+        assertThat(resultMap).hasSize(3);
         // Verifies the first timestamp result.
         List<BatteryDiffEntry> entryList = resultMap.get(Integer.valueOf(0));
         assertThat(entryList).hasSize(1);
-        assertBatteryDiffEntry(entryList.get(0), 100.0, 15L, 25L);
+        assertBatteryDiffEntry(entryList.get(0), 100, 15L, 25L);
         // Verifies the second timestamp result.
         entryList = resultMap.get(Integer.valueOf(1));
         assertThat(entryList).hasSize(3);
-        assertBatteryDiffEntry(entryList.get(0), 5.0, 5L, 5L);
+        assertBatteryDiffEntry(entryList.get(0), 5, 5L, 5L);
-        assertBatteryDiffEntry(entryList.get(1), 75.0, 40L, 50L);
+        assertBatteryDiffEntry(entryList.get(1), 75, 40L, 50L);
-        assertBatteryDiffEntry(entryList.get(2), 20.0, 15L, 15L);
+        assertBatteryDiffEntry(entryList.get(2), 20, 15L, 15L);
+        // Verifies the last 24 hours aggregate result.
+        entryList = resultMap.get(Integer.valueOf(-1));
+        assertThat(entryList).hasSize(3);
+        assertBatteryDiffEntry(entryList.get(0), 4, 5L, 5L);
+        assertBatteryDiffEntry(entryList.get(1), 68, 40L, 50L);
+        assertBatteryDiffEntry(entryList.get(2), 27, 30L, 40L);
     }
 
     private static BatteryHistEntry createBatteryHistEntry(
@@ -238,9 +244,9 @@ public final class ConvertUtilsTest {
     }
 
     private static void assertBatteryDiffEntry(
-            BatteryDiffEntry entry, double percentOfTotal,
+            BatteryDiffEntry entry, int percentOfTotal,
             long foregroundUsageTimeInMs, long backgroundUsageTimeInMs) {
-        assertThat(entry.getPercentOfTotal()).isEqualTo(percentOfTotal);
+        assertThat((int) entry.getPercentOfTotal()).isEqualTo(percentOfTotal);
         assertThat(entry.mForegroundUsageTimeInMs).isEqualTo(foregroundUsageTimeInMs);
         assertThat(entry.mBackgroundUsageTimeInMs).isEqualTo(backgroundUsageTimeInMs);
     }