diff --git a/core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java b/core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java
index 0b72c3c..16bb000 100644
--- a/core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java
+++ b/core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java
@@ -54,8 +54,8 @@
         // record data into narrow window to get single bucket
         stats.recordData(TEST_START, TEST_START + SECOND_IN_MILLIS, 1024L, 2048L);
 
-        assertEquals(1, stats.bucketCount);
-        assertBucket(stats, 0, 1024L, 2048L);
+        assertEquals(1, stats.size());
+        assertEntry(stats, 0, 1024L, 2048L);
     }
 
     public void testRecordEqualBuckets() throws Exception {
@@ -66,9 +66,9 @@
         final long recordStart = TEST_START + (bucketDuration / 2);
         stats.recordData(recordStart, recordStart + bucketDuration, 1024L, 128L);
 
-        assertEquals(2, stats.bucketCount);
-        assertBucket(stats, 0, 512L, 64L);
-        assertBucket(stats, 1, 512L, 64L);
+        assertEquals(2, stats.size());
+        assertEntry(stats, 0, 512L, 64L);
+        assertEntry(stats, 1, 512L, 64L);
     }
 
     public void testRecordTouchingBuckets() throws Exception {
@@ -81,13 +81,13 @@
         final long recordEnd = (TEST_START + (BUCKET_SIZE * 2)) + (MINUTE_IN_MILLIS * 4);
         stats.recordData(recordStart, recordEnd, 1000L, 5000L);
 
-        assertEquals(3, stats.bucketCount);
+        assertEquals(3, stats.size());
         // first bucket should have (1/20 of value)
-        assertBucket(stats, 0, 50L, 250L);
+        assertEntry(stats, 0, 50L, 250L);
         // second bucket should have (15/20 of value)
-        assertBucket(stats, 1, 750L, 3750L);
+        assertEntry(stats, 1, 750L, 3750L);
         // final bucket should have (4/20 of value)
-        assertBucket(stats, 2, 200L, 1000L);
+        assertEntry(stats, 2, 200L, 1000L);
     }
 
     public void testRecordGapBuckets() throws Exception {
@@ -101,9 +101,9 @@
         stats.recordData(lastStart, lastStart + SECOND_IN_MILLIS, 64L, 512L);
 
         // we should have two buckets, far apart from each other
-        assertEquals(2, stats.bucketCount);
-        assertBucket(stats, 0, 128L, 256L);
-        assertBucket(stats, 1, 64L, 512L);
+        assertEquals(2, stats.size());
+        assertEntry(stats, 0, 128L, 256L);
+        assertEntry(stats, 1, 64L, 512L);
 
         // now record something in middle, spread across two buckets
         final long middleStart = TEST_START + DAY_IN_MILLIS;
@@ -111,11 +111,11 @@
         stats.recordData(middleStart, middleEnd, 2048L, 2048L);
 
         // now should have four buckets, with new record in middle two buckets
-        assertEquals(4, stats.bucketCount);
-        assertBucket(stats, 0, 128L, 256L);
-        assertBucket(stats, 1, 1024L, 1024L);
-        assertBucket(stats, 2, 1024L, 1024L);
-        assertBucket(stats, 3, 64L, 512L);
+        assertEquals(4, stats.size());
+        assertEntry(stats, 0, 128L, 256L);
+        assertEntry(stats, 1, 1024L, 1024L);
+        assertEntry(stats, 2, 1024L, 1024L);
+        assertEntry(stats, 3, 64L, 512L);
     }
 
     public void testRecordOverlapBuckets() throws Exception {
@@ -128,9 +128,9 @@
         stats.recordData(midStart, midStart + HOUR_IN_MILLIS, 1024L, 1024L);
 
         // should have two buckets, with some data mixed together
-        assertEquals(2, stats.bucketCount);
-        assertBucket(stats, 0, 768L, 768L);
-        assertBucket(stats, 1, 512L, 512L);
+        assertEquals(2, stats.size());
+        assertEntry(stats, 0, 768L, 768L);
+        assertEntry(stats, 1, 512L, 512L);
     }
 
     public void testRecordEntireGapIdentical() throws Exception {
@@ -154,10 +154,10 @@
         assertTotalEquals(total, 3000L, 1500L);
 
         // now inspect internal buckets
-        assertBucket(stats, 0, 1000L, 500L);
-        assertBucket(stats, 1, 1000L, 500L);
-        assertBucket(stats, 2, 500L, 250L);
-        assertBucket(stats, 3, 500L, 250L);
+        assertEntry(stats, 0, 1000L, 500L);
+        assertEntry(stats, 1, 1000L, 500L);
+        assertEntry(stats, 2, 500L, 250L);
+        assertEntry(stats, 3, 500L, 250L);
     }
 
     public void testRecordEntireOverlapVaryingBuckets() throws Exception {
@@ -181,13 +181,13 @@
         assertTotalEquals(total, 650L, 650L);
 
         // now inspect internal buckets
-        assertBucket(stats, 0, 10L, 10L);
-        assertBucket(stats, 1, 20L, 20L);
-        assertBucket(stats, 2, 20L, 20L);
-        assertBucket(stats, 3, 20L, 20L);
-        assertBucket(stats, 4, 20L, 20L);
-        assertBucket(stats, 5, 20L, 20L);
-        assertBucket(stats, 6, 10L, 10L);
+        assertEntry(stats, 0, 10L, 10L);
+        assertEntry(stats, 1, 20L, 20L);
+        assertEntry(stats, 2, 20L, 20L);
+        assertEntry(stats, 3, 20L, 20L);
+        assertEntry(stats, 4, 20L, 20L);
+        assertEntry(stats, 5, 20L, 20L);
+        assertEntry(stats, 6, 10L, 10L);
 
         // now combine using 15min buckets
         stats = new NetworkStatsHistory(HOUR_IN_MILLIS / 4);
@@ -199,10 +199,10 @@
         assertTotalEquals(total, 650L, 650L);
 
         // and inspect buckets
-        assertBucket(stats, 0, 200L, 200L);
-        assertBucket(stats, 1, 150L, 150L);
-        assertBucket(stats, 2, 150L, 150L);
-        assertBucket(stats, 3, 150L, 150L);
+        assertEntry(stats, 0, 200L, 200L);
+        assertEntry(stats, 1, 150L, 150L);
+        assertEntry(stats, 2, 150L, 150L);
+        assertEntry(stats, 3, 150L, 150L);
     }
 
     public void testRemove() throws Exception {
@@ -210,28 +210,28 @@
 
         // record some data across 24 buckets
         stats.recordData(TEST_START, TEST_START + DAY_IN_MILLIS, 24L, 24L);
-        assertEquals(24, stats.bucketCount);
+        assertEquals(24, stats.size());
 
         // try removing far before buckets; should be no change
         stats.removeBucketsBefore(TEST_START - YEAR_IN_MILLIS);
-        assertEquals(24, stats.bucketCount);
+        assertEquals(24, stats.size());
 
         // try removing just moments into first bucket; should be no change
         // since that bucket contains data beyond the cutoff
         stats.removeBucketsBefore(TEST_START + SECOND_IN_MILLIS);
-        assertEquals(24, stats.bucketCount);
+        assertEquals(24, stats.size());
 
         // try removing single bucket
         stats.removeBucketsBefore(TEST_START + HOUR_IN_MILLIS);
-        assertEquals(23, stats.bucketCount);
+        assertEquals(23, stats.size());
 
         // try removing multiple buckets
         stats.removeBucketsBefore(TEST_START + (4 * HOUR_IN_MILLIS));
-        assertEquals(20, stats.bucketCount);
+        assertEquals(20, stats.size());
 
         // try removing all buckets
         stats.removeBucketsBefore(TEST_START + YEAR_IN_MILLIS);
-        assertEquals(0, stats.bucketCount);
+        assertEquals(0, stats.size());
     }
 
     public void testTotalData() throws Exception {
@@ -293,19 +293,25 @@
 
     private static void assertConsistent(NetworkStatsHistory stats) {
         // verify timestamps are monotonic
-        for (int i = 1; i < stats.bucketCount; i++) {
-            assertTrue(stats.bucketStart[i - 1] < stats.bucketStart[i]);
+        long lastStart = Long.MIN_VALUE;
+        NetworkStatsHistory.Entry entry = null;
+        for (int i = 0; i < stats.size(); i++) {
+            entry = stats.getValues(i, entry);
+            assertTrue(lastStart < entry.bucketStart);
+            lastStart = entry.bucketStart;
         }
     }
 
-    private static void assertTotalEquals(long[] total, long rx, long tx) {
-        assertEquals("unexpected rx", rx, total[0]);
-        assertEquals("unexpected tx", tx, total[1]);
+    private static void assertTotalEquals(long[] total, long rxBytes, long txBytes) {
+        assertEquals("unexpected rxBytes", rxBytes, total[0]);
+        assertEquals("unexpected txBytes", txBytes, total[1]);
     }
 
-    private static void assertBucket(NetworkStatsHistory stats, int index, long rx, long tx) {
-        assertEquals("unexpected rx", rx, stats.rx[index]);
-        assertEquals("unexpected tx", tx, stats.tx[index]);
+    private static void assertEntry(
+            NetworkStatsHistory stats, int index, long rxBytes, long txBytes) {
+        final NetworkStatsHistory.Entry entry = stats.getValues(index, null);
+        assertEquals("unexpected rxBytes", rxBytes, entry.rxBytes);
+        assertEquals("unexpected txBytes", txBytes, entry.txBytes);
     }
 
 }
diff --git a/core/tests/coretests/src/android/net/NetworkStatsTest.java b/core/tests/coretests/src/android/net/NetworkStatsTest.java
index 82345e2..2434e9f 100644
--- a/core/tests/coretests/src/android/net/NetworkStatsTest.java
+++ b/core/tests/coretests/src/android/net/NetworkStatsTest.java
@@ -31,9 +31,9 @@
 
     public void testFindIndex() throws Exception {
         final NetworkStats stats = new NetworkStats(TEST_START, 3)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L)
-                .addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
+                .addValues(TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
 
         assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE));
         assertEquals(2, stats.findIndex(TEST_IFACE, 102, TAG_NONE));
@@ -45,109 +45,105 @@
         final NetworkStats stats = new NetworkStats(TEST_START, 2);
 
         assertEquals(0, stats.size());
-        assertEquals(2, stats.iface.length);
+        assertEquals(2, stats.internalSize());
 
-        stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 2L);
-        stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L);
+        stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
+        stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
 
         assertEquals(2, stats.size());
-        assertEquals(2, stats.iface.length);
+        assertEquals(2, stats.internalSize());
 
-        stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 4L);
-        stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 4L);
-        stats.addEntry(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 5L);
+        stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
+        stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
+        stats.addValues(TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
 
         assertEquals(5, stats.size());
-        assertTrue(stats.iface.length >= 5);
+        assertTrue(stats.internalSize() >= 5);
 
-        assertEquals(1L, stats.rx[0]);
-        assertEquals(2L, stats.rx[1]);
-        assertEquals(3L, stats.rx[2]);
-        assertEquals(4L, stats.rx[3]);
-        assertEquals(5L, stats.rx[4]);
+        assertEntry(stats, 0, TEST_IFACE, TEST_UID, TAG_NONE, 1L, 1L, 2L, 2L);
+        assertEntry(stats, 1, TEST_IFACE, TEST_UID, TAG_NONE, 2L, 2L, 2L, 2L);
+        assertEntry(stats, 2, TEST_IFACE, TEST_UID, TAG_NONE, 3L, 30L, 4L, 40L);
+        assertEntry(stats, 3, TEST_IFACE, TEST_UID, TAG_NONE, 4L, 40L, 4L, 40L);
+        assertEntry(stats, 4, TEST_IFACE, TEST_UID, TAG_NONE, 5L, 50L, 5L, 50L);
     }
 
     public void testCombineExisting() throws Exception {
         final NetworkStats stats = new NetworkStats(TEST_START, 10);
 
-        stats.addEntry(TEST_IFACE, 1001, TAG_NONE, 512L, 256L);
-        stats.addEntry(TEST_IFACE, 1001, 0xff, 128L, 128L);
-        stats.combineEntry(TEST_IFACE, 1001, TAG_NONE, -128L, -128L);
+        stats.addValues(TEST_IFACE, 1001, TAG_NONE, 512L, 4L, 256L, 2L);
+        stats.addValues(TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
+        stats.combineValues(TEST_IFACE, 1001, TAG_NONE, -128L, -1L, -128L, -1L);
 
-        assertStatsEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 128L);
-        assertStatsEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 128L);
+        assertEntry(stats, 0, TEST_IFACE, 1001, TAG_NONE, 384L, 3L, 128L, 1L);
+        assertEntry(stats, 1, TEST_IFACE, 1001, 0xff, 128L, 1L, 128L, 1L);
 
         // now try combining that should create row
-        stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
-        assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
-        stats.combineEntry(TEST_IFACE, 5005, TAG_NONE, 128L, 128L);
-        assertStatsEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 256L);
+        stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
+        assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
+        stats.combineValues(TEST_IFACE, 5005, TAG_NONE, 128L, 1L, 128L, 1L);
+        assertEntry(stats, 2, TEST_IFACE, 5005, TAG_NONE, 256L, 2L, 256L, 2L);
     }
 
     public void testSubtractIdenticalData() throws Exception {
         final NetworkStats before = new NetworkStats(TEST_START, 2)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
 
         final NetworkStats after = new NetworkStats(TEST_START, 2)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
 
         final NetworkStats result = after.subtract(before);
 
         // identical data should result in zero delta
-        assertEquals(0, result.rx[0]);
-        assertEquals(0, result.tx[0]);
-        assertEquals(0, result.rx[1]);
-        assertEquals(0, result.tx[1]);
+        assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
+        assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
     }
 
     public void testSubtractIdenticalRows() throws Exception {
         final NetworkStats before = new NetworkStats(TEST_START, 2)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
 
         final NetworkStats after = new NetworkStats(TEST_START, 2)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1025L, 2L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 3L, 1028L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1025L, 9L, 2L, 1L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 3L, 1L, 1028L, 9L);
 
         final NetworkStats result = after.subtract(before);
 
         // expect delta between measurements
-        assertEquals(1, result.rx[0]);
-        assertEquals(2, result.tx[0]);
-        assertEquals(3, result.rx[1]);
-        assertEquals(4, result.tx[1]);
+        assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 1L, 1L, 2L, 1L);
+        assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 3L, 1L, 4L, 1L);
     }
 
     public void testSubtractNewRows() throws Exception {
         final NetworkStats before = new NetworkStats(TEST_START, 2)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L);
 
         final NetworkStats after = new NetworkStats(TEST_START, 3)
-                .addEntry(TEST_IFACE, 100, TAG_NONE, 1024L, 0L)
-                .addEntry(TEST_IFACE, 101, TAG_NONE, 0L, 1024L)
-                .addEntry(TEST_IFACE, 102, TAG_NONE, 1024L, 1024L);
+                .addValues(TEST_IFACE, 100, TAG_NONE, 1024L, 8L, 0L, 0L)
+                .addValues(TEST_IFACE, 101, TAG_NONE, 0L, 0L, 1024L, 8L)
+                .addValues(TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
 
         final NetworkStats result = after.subtract(before);
 
         // its okay to have new rows
-        assertEquals(0, result.rx[0]);
-        assertEquals(0, result.tx[0]);
-        assertEquals(0, result.rx[1]);
-        assertEquals(0, result.tx[1]);
-        assertEquals(1024, result.rx[2]);
-        assertEquals(1024, result.tx[2]);
+        assertEntry(result, 0, TEST_IFACE, 100, TAG_NONE, 0L, 0L, 0L, 0L);
+        assertEntry(result, 1, TEST_IFACE, 101, TAG_NONE, 0L, 0L, 0L, 0L);
+        assertEntry(result, 2, TEST_IFACE, 102, TAG_NONE, 1024L, 8L, 1024L, 8L);
     }
 
-    private static void assertStatsEntry(
-            NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) {
-        assertEquals(iface, stats.iface[i]);
-        assertEquals(uid, stats.uid[i]);
-        assertEquals(tag, stats.tag[i]);
-        assertEquals(rx, stats.rx[i]);
-        assertEquals(tx, stats.tx[i]);
+    private static void assertEntry(NetworkStats stats, int index, String iface, int uid, int tag,
+            long rxBytes, long rxPackets, long txBytes, long txPackets) {
+        final NetworkStats.Entry entry = stats.getValues(index, null);
+        assertEquals(iface, entry.iface);
+        assertEquals(uid, entry.uid);
+        assertEquals(tag, entry.tag);
+        assertEquals(rxBytes, entry.rxBytes);
+        assertEquals(rxPackets, entry.rxPackets);
+        assertEquals(txBytes, entry.txBytes);
+        assertEquals(txPackets, entry.txPackets);
     }
 
 }
diff --git a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
index f2c28bb..36b3b82 100644
--- a/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/NetworkStatsServiceTest.java
@@ -168,7 +168,7 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 2048L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 1L, 2048L, 2L));
         expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
 
         replay();
@@ -184,7 +184,7 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 4096L, 8192L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 4096L, 4L, 8192L, 8L));
         expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
 
         replay();
@@ -219,10 +219,10 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 2048L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 1024L, 8L, 2048L, 16L));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 2)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 512L, 256L)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 128L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 512L, 4L, 256L, 2L)
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 128L, 1L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -284,7 +284,7 @@
         expectTime(TEST_START + elapsedRealtime);
         expectSettings(0L, HOUR_IN_MILLIS, WEEK_IN_MILLIS);
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 512L, 512L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 512L, 4L, 512L, 4L));
         expectNetworkStatsDetail(buildEmptyStats(elapsedRealtime));
 
         replay();
@@ -295,8 +295,8 @@
         total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null);
         assertEquals(512L, total[0]);
         assertEquals(512L, total[1]);
-        assertEquals(HOUR_IN_MILLIS, history.bucketDuration);
-        assertEquals(2, history.bucketCount);
+        assertEquals(HOUR_IN_MILLIS, history.getBucketDuration());
+        assertEquals(2, history.size());
         verifyAndReset();
 
         // now change bucket duration setting and trigger another poll with
@@ -314,8 +314,8 @@
         total = history.getTotalData(Long.MIN_VALUE, Long.MAX_VALUE, null);
         assertEquals(512L, total[0]);
         assertEquals(512L, total[1]);
-        assertEquals(30 * MINUTE_IN_MILLIS, history.bucketDuration);
-        assertEquals(4, history.bucketCount);
+        assertEquals(30 * MINUTE_IN_MILLIS, history.getBucketDuration());
+        assertEquals(4, history.size());
         verifyAndReset();
 
     }
@@ -338,11 +338,11 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 2048L, 512L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 2048L, 16L, 512L, 4L));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 3)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 512L)
-                .addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 0L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 1536L, 12L, 512L, 4L)
+                .addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L)
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 512L, 4L, 0L, 0L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -373,9 +373,9 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 128L, 1024L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 128L, 1L, 1024L, 8L));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1024L));
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 128L, 1L, 1024L, 8L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -412,11 +412,11 @@
         expectTime(TEST_START + elapsedRealtime);
         expectDefaultSettings();
         expectNetworkStatsSummary(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_ALL, TAG_NONE, 4128L, 544L));
+                .addValues(TEST_IFACE, UID_ALL, TAG_NONE, 4128L, 258L, 544L, 34L));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 16L, 16L)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 512L)
-                .addEntry(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 16L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 16L, 1L, 16L, 1L)
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 4096L, 258L, 512L, 32L)
+                .addValues(TEST_IFACE, UID_GREEN, TAG_NONE, 16L, 1L, 16L, 1L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -468,8 +468,8 @@
         expectDefaultSettings();
         expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 1024L)
-                .addEntry(TEST_IFACE, UID_RED, 0xF00D, 512L, 512L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 1024L, 8L, 1024L, 8L)
+                .addValues(TEST_IFACE, UID_RED, 0xF00D, 512L, 4L, 512L, 4L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -497,7 +497,7 @@
         expectDefaultSettings();
         expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 512L, 256L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 512L, 4L, 256L, 2L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -548,9 +548,9 @@
         expectDefaultSettings();
         expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_RED, TAG_NONE, 50L, 50L)
-                .addEntry(TEST_IFACE, UID_RED, 0xF00D, 10L, 10L)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 512L));
+                .addValues(TEST_IFACE, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L)
+                .addValues(TEST_IFACE, UID_RED, 0xF00D, 10L, 1L, 10L, 1L)
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -566,7 +566,7 @@
         expectDefaultSettings();
         expectNetworkStatsSummary(buildEmptyStats(elapsedRealtime));
         expectNetworkStatsDetail(new NetworkStats(elapsedRealtime, 1)
-                .addEntry(TEST_IFACE, UID_BLUE, TAG_NONE, 2048L, 1024L));
+                .addValues(TEST_IFACE, UID_BLUE, TAG_NONE, 2048L, 16L, 1024L, 8L));
 
         replay();
         mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
@@ -574,17 +574,17 @@
         // first verify entire history present
         NetworkStats stats = mService.getSummaryForAllUid(
                 sTemplateWifi, Long.MIN_VALUE, Long.MAX_VALUE, true);
-        assertEquals(3, stats.size);
-        assertStatsEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 50L);
-        assertStatsEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 10L);
-        assertStatsEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 1024L);
+        assertEquals(3, stats.size());
+        assertEntry(stats, 0, IFACE_ALL, UID_RED, TAG_NONE, 50L, 5L, 50L, 5L);
+        assertEntry(stats, 1, IFACE_ALL, UID_RED, 0xF00D, 10L, 1L, 10L, 1L);
+        assertEntry(stats, 2, IFACE_ALL, UID_BLUE, TAG_NONE, 2048L, 16L, 1024L, 8L);
 
         // now verify that recent history only contains one uid
         final long currentTime = TEST_START + elapsedRealtime;
         stats = mService.getSummaryForAllUid(
                 sTemplateWifi, currentTime - HOUR_IN_MILLIS, currentTime, true);
-        assertEquals(1, stats.size);
-        assertStatsEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 512L);
+        assertEquals(1, stats.size());
+        assertEntry(stats, 0, IFACE_ALL, UID_BLUE, TAG_NONE, 1024L, 8L, 512L, 4L);
 
         verifyAndReset();
     }
@@ -660,13 +660,17 @@
         }
     }
 
-    private static void assertStatsEntry(
-            NetworkStats stats, int i, String iface, int uid, int tag, long rx, long tx) {
-        assertEquals(iface, stats.iface[i]);
-        assertEquals(uid, stats.uid[i]);
-        assertEquals(tag, stats.tag[i]);
-        assertEquals(rx, stats.rx[i]);
-        assertEquals(tx, stats.tx[i]);
+    private static void assertEntry(NetworkStats stats, int i, String iface, int uid, int tag,
+            long rxBytes, long rxPackets, long txBytes, long txPackets) {
+        final NetworkStats.Entry entry = stats.getValues(i, null);
+        assertEquals(iface, entry.iface);
+        assertEquals(uid, entry.uid);
+        assertEquals(tag, entry.tag);
+        assertEquals(rxBytes, entry.rxBytes);
+        // TODO: enable testing packet counts once stored in history
+//        assertEquals(rxPackets, entry.rxPackets);
+        assertEquals(txBytes, entry.txBytes);
+//        assertEquals(txPackets, entry.txPackets);
     }
 
     private static NetworkState buildWifiState() {