Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d37948f6 authored by Jeff Sharkey's avatar Jeff Sharkey
Browse files

Hide NetworkStatsHistory internals. 

Instead of exposing internal storage details, offer getValues()
accessor which populates values into a recycled structure.

Change-Id: I5228d7099a8f61b2018a435a813435a67dae49b4
parent 1ea4cc64

core/java/android/net/NetworkStats.java

+61 −56
Original line number Diff line number Diff line
@@ -43,31 +43,19 @@ public class NetworkStats implements Parcelable { 
    /** {@link #tag} value for without tag. */

    public static final int TAG_NONE = 0;



    // TODO: move public fields to Entry accessors, then undeprecate

    // TODO: refactor rx/tx to rxBytes/txBytes



    /**

     * {@link SystemClock#elapsedRealtime()} timestamp when this data was

     * generated.

     */

    @Deprecated

    public final long elapsedRealtime;

    @Deprecated

    public int size;

    @Deprecated

    public String[] iface;

    @Deprecated

    public int[] uid;

    @Deprecated

    public int[] tag;

    @Deprecated

    public long[] rx;

    @Deprecated

    public long[] rxPackets;

    @Deprecated

    public long[] tx;

    @Deprecated

    public long[] txPackets;

    private final long elapsedRealtime;

    private int size;

    private String[] iface;

    private int[] uid;

    private int[] tag;

    private long[] rxBytes;

    private long[] rxPackets;

    private long[] txBytes;

    private long[] txPackets;



    public static class Entry {

        public String iface;
@@ -77,6 +65,20 @@ public class NetworkStats implements Parcelable { 
        public long rxPackets;

        public long txBytes;

        public long txPackets;



        public Entry() {

        }



        public Entry(String iface, int uid, int tag, long rxBytes, long rxPackets, long txBytes,

                long txPackets) {

            this.iface = iface;

            this.uid = uid;

            this.tag = tag;

            this.rxBytes = rxBytes;

            this.rxPackets = rxPackets;

            this.txBytes = txBytes;

            this.txPackets = txPackets;

        }

    }



    public NetworkStats(long elapsedRealtime, int initialSize) {
@@ -85,9 +87,9 @@ public class NetworkStats implements Parcelable { 
        this.iface = new String[initialSize];

        this.uid = new int[initialSize];

        this.tag = new int[initialSize];

        this.rx = new long[initialSize];

        this.rxBytes = new long[initialSize];

        this.rxPackets = new long[initialSize];

        this.tx = new long[initialSize];

        this.txBytes = new long[initialSize];

        this.txPackets = new long[initialSize];

    }
@@ -97,23 +99,15 @@ public class NetworkStats implements Parcelable { 
        iface = parcel.createStringArray();

        uid = parcel.createIntArray();

        tag = parcel.createIntArray();

        rx = parcel.createLongArray();

        rxBytes = parcel.createLongArray();

        rxPackets = parcel.createLongArray();

        tx = parcel.createLongArray();

        txBytes = parcel.createLongArray();

        txPackets = parcel.createLongArray();

    }



    /**

     * Add new stats entry with given values.

     */

    public NetworkStats addEntry(String iface, int uid, int tag, long rx, long tx) {

        final Entry entry = new Entry();

        entry.iface = iface;

        entry.uid = uid;

        entry.tag = tag;

        entry.rxBytes = rx;

        entry.txBytes = tx;

        return addValues(entry);

    public NetworkStats addValues(String iface, int uid, int tag, long rxBytes, long rxPackets,

            long txBytes, long txPackets) {

        return addValues(new Entry(iface, uid, tag, rxBytes, rxPackets, txBytes, txPackets));

    }



    /**
@@ -126,18 +120,18 @@ public class NetworkStats implements Parcelable { 
            iface = Arrays.copyOf(iface, newLength);

            uid = Arrays.copyOf(uid, newLength);

            tag = Arrays.copyOf(tag, newLength);

            rx = Arrays.copyOf(rx, newLength);

            rxBytes = Arrays.copyOf(rxBytes, newLength);

            rxPackets = Arrays.copyOf(rxPackets, newLength);

            tx = Arrays.copyOf(tx, newLength);

            txBytes = Arrays.copyOf(txBytes, newLength);

            txPackets = Arrays.copyOf(txPackets, newLength);

        }



        iface[size] = entry.iface;

        uid[size] = entry.uid;

        tag[size] = entry.tag;

        rx[size] = entry.rxBytes;

        rxBytes[size] = entry.rxBytes;

        rxPackets[size] = entry.rxPackets;

        tx[size] = entry.txBytes;

        txBytes[size] = entry.txBytes;

        txPackets[size] = entry.txPackets;

        size++;
@@ -152,9 +146,9 @@ public class NetworkStats implements Parcelable { 
        entry.iface = iface[i];

        entry.uid = uid[i];

        entry.tag = tag[i];

        entry.rxBytes = rx[i];

        entry.rxBytes = rxBytes[i];

        entry.rxPackets = rxPackets[i];

        entry.txBytes = tx[i];

        entry.txBytes = txBytes[i];

        entry.txPackets = txPackets[i];

        return entry;

    }
@@ -167,20 +161,31 @@ public class NetworkStats implements Parcelable { 
        return size;

    }



    // @VisibleForTesting

    public int internalSize() {

        return iface.length;

    }



    public NetworkStats combineValues(String iface, int uid, int tag, long rxBytes, long rxPackets,

            long txBytes, long txPackets) {

        return combineValues(new Entry(iface, uid, tag, rxBytes, rxPackets, txBytes, txPackets));

    }



    /**

     * Combine given values with an existing row, or create a new row if

     * {@link #findIndex(String, int, int)} is unable to find match. Can also be

     * used to subtract values from existing rows.

     */

    public NetworkStats combineEntry(String iface, int uid, int tag, long rx, long tx) {

        // TODO: extent to accept rxPackets/txPackets

        final int i = findIndex(iface, uid, tag);

    public NetworkStats combineValues(Entry entry) {

        final int i = findIndex(entry.iface, entry.uid, entry.tag);

        if (i == -1) {

            // only create new entry when positive contribution

            addEntry(iface, uid, tag, rx, tx);

            addValues(entry);

        } else {

            this.rx[i] += rx;

            this.tx[i] += tx;

            rxBytes[i] += entry.rxBytes;

            rxPackets[i] += entry.rxPackets;

            txBytes[i] += entry.txBytes;

            txPackets[i] += entry.txPackets;

        }

        return this;

    }
@@ -280,15 +285,15 @@ public class NetworkStats implements Parcelable { 
            final int j = value.findIndex(entry.iface, entry.uid, entry.tag);

            if (j == -1) {

                // newly appearing row, return entire value

                entry.rxBytes = rx[i];

                entry.rxBytes = rxBytes[i];

                entry.rxPackets = rxPackets[i];

                entry.txBytes = tx[i];

                entry.txBytes = txBytes[i];

                entry.txPackets = txPackets[i];

            } else {

                // existing row, subtract remote value

                entry.rxBytes = rx[i] - value.rx[j];

                entry.rxBytes = rxBytes[i] - value.rxBytes[j];

                entry.rxPackets = rxPackets[i] - value.rxPackets[j];

                entry.txBytes = tx[i] - value.tx[j];

                entry.txBytes = txBytes[i] - value.txBytes[j];

                entry.txPackets = txPackets[i] - value.txPackets[j];

                if (enforceMonotonic

                        && (entry.rxBytes < 0 || entry.rxPackets < 0 || entry.txBytes < 0
@@ -321,9 +326,9 @@ public class NetworkStats implements Parcelable { 
            pw.print("  iface="); pw.print(iface[i]);

            pw.print(" uid="); pw.print(uid[i]);

            pw.print(" tag="); pw.print(tag[i]);

            pw.print(" rxBytes="); pw.print(rx[i]);

            pw.print(" rxBytes="); pw.print(rxBytes[i]);

            pw.print(" rxPackets="); pw.print(rxPackets[i]);

            pw.print(" txBytes="); pw.print(tx[i]);

            pw.print(" txBytes="); pw.print(txBytes[i]);

            pw.print(" txPackets="); pw.println(txPackets[i]);

        }

    }
@@ -347,9 +352,9 @@ public class NetworkStats implements Parcelable { 
        dest.writeStringArray(iface);

        dest.writeIntArray(uid);

        dest.writeIntArray(tag);

        dest.writeLongArray(rx);

        dest.writeLongArray(rxBytes);

        dest.writeLongArray(rxPackets);

        dest.writeLongArray(tx);

        dest.writeLongArray(txBytes);

        dest.writeLongArray(txPackets);

    }

core/java/android/net/NetworkStatsHistory.java

+59 −32
Original line number Diff line number Diff line
@@ -43,13 +43,20 @@ public class NetworkStatsHistory implements Parcelable { 
    private static final int VERSION_INIT = 1;



    // TODO: teach about varint encoding to use less disk space

    // TODO: extend to record rxPackets/txPackets



    public final long bucketDuration;

    private final long bucketDuration;

    private int bucketCount;

    private long[] bucketStart;

    private long[] rxBytes;

    private long[] txBytes;



    public int bucketCount;

    public long[] bucketStart;

    public long[] rx;

    public long[] tx;

    public static class Entry {

        public long bucketStart;

        public long bucketDuration;

        public long rxBytes;

        public long txBytes;

    }



    public NetworkStatsHistory(long bucketDuration) {

        this(bucketDuration, 10);
@@ -58,16 +65,16 @@ public class NetworkStatsHistory implements Parcelable { 
    public NetworkStatsHistory(long bucketDuration, int initialSize) {

        this.bucketDuration = bucketDuration;

        bucketStart = new long[initialSize];

        rx = new long[initialSize];

        tx = new long[initialSize];

        rxBytes = new long[initialSize];

        txBytes = new long[initialSize];

        bucketCount = 0;

    }



    public NetworkStatsHistory(Parcel in) {

        bucketDuration = in.readLong();

        bucketStart = readLongArray(in);

        rx = in.createLongArray();

        tx = in.createLongArray();

        rxBytes = in.createLongArray();

        txBytes = in.createLongArray();

        bucketCount = bucketStart.length;

    }
@@ -75,8 +82,8 @@ public class NetworkStatsHistory implements Parcelable { 
    public void writeToParcel(Parcel out, int flags) {

        out.writeLong(bucketDuration);

        writeLongArray(out, bucketStart, bucketCount);

        writeLongArray(out, rx, bucketCount);

        writeLongArray(out, tx, bucketCount);

        writeLongArray(out, rxBytes, bucketCount);

        writeLongArray(out, txBytes, bucketCount);

    }



    public NetworkStatsHistory(DataInputStream in) throws IOException {
@@ -85,8 +92,8 @@ public class NetworkStatsHistory implements Parcelable { 
            case VERSION_INIT: {

                bucketDuration = in.readLong();

                bucketStart = readLongArray(in);

                rx = readLongArray(in);

                tx = readLongArray(in);

                rxBytes = readLongArray(in);

                txBytes = readLongArray(in);

                bucketCount = bucketStart.length;

                break;

            }
@@ -100,8 +107,8 @@ public class NetworkStatsHistory implements Parcelable { 
        out.writeInt(VERSION_INIT);

        out.writeLong(bucketDuration);

        writeLongArray(out, bucketStart, bucketCount);

        writeLongArray(out, rx, bucketCount);

        writeLongArray(out, tx, bucketCount);

        writeLongArray(out, rxBytes, bucketCount);

        writeLongArray(out, txBytes, bucketCount);

    }



    /** {@inheritDoc} */
@@ -109,6 +116,26 @@ public class NetworkStatsHistory implements Parcelable { 
        return 0;

    }



    public int size() {

        return bucketCount;

    }



    public long getBucketDuration() {

        return bucketDuration;

    }



    /**

     * Return specific stats entry.

     */

    public Entry getValues(int i, Entry recycle) {

        final Entry entry = recycle != null ? recycle : new Entry();

        entry.bucketStart = bucketStart[i];

        entry.bucketDuration = bucketDuration;

        entry.rxBytes = rxBytes[i];

        entry.txBytes = txBytes[i];

        return entry;

    }



    /**

     * Record that data traffic occurred in the given time range. Will

     * distribute across internal buckets, creating new buckets as needed.
@@ -135,8 +162,8 @@ public class NetworkStatsHistory implements Parcelable { 


            final long overlap = Math.min(curEnd, end) - Math.max(curStart, start);

            if (overlap > 0) {

                this.rx[i] += rx * overlap / duration;

                this.tx[i] += tx * overlap / duration;

                this.rxBytes[i] += rx * overlap / duration;

                this.txBytes[i] += tx * overlap / duration;

            }

        }

    }
@@ -149,7 +176,7 @@ public class NetworkStatsHistory implements Parcelable { 
        for (int i = 0; i < input.bucketCount; i++) {

            final long start = input.bucketStart[i];

            final long end = start + input.bucketDuration;

            recordData(start, end, input.rx[i], input.tx[i]);

            recordData(start, end, input.rxBytes[i], input.txBytes[i]);

        }

    }
@@ -179,8 +206,8 @@ public class NetworkStatsHistory implements Parcelable { 
        if (bucketCount >= bucketStart.length) {

            final int newLength = Math.max(bucketStart.length, 10) * 3 / 2;

            bucketStart = Arrays.copyOf(bucketStart, newLength);

            rx = Arrays.copyOf(rx, newLength);

            tx = Arrays.copyOf(tx, newLength);

            rxBytes = Arrays.copyOf(rxBytes, newLength);

            txBytes = Arrays.copyOf(txBytes, newLength);

        }



        // create gap when inserting bucket in middle
@@ -189,13 +216,13 @@ public class NetworkStatsHistory implements Parcelable { 
            final int length = bucketCount - index;



            System.arraycopy(bucketStart, index, bucketStart, dstPos, length);

            System.arraycopy(rx, index, rx, dstPos, length);

            System.arraycopy(tx, index, tx, dstPos, length);

            System.arraycopy(rxBytes, index, rxBytes, dstPos, length);

            System.arraycopy(txBytes, index, txBytes, dstPos, length);

        }



        bucketStart[index] = start;

        rx[index] = 0;

        tx[index] = 0;

        rxBytes[index] = 0;

        txBytes[index] = 0;

        bucketCount++;

    }
@@ -216,8 +243,8 @@ public class NetworkStatsHistory implements Parcelable { 
        if (i > 0) {

            final int length = bucketStart.length;

            bucketStart = Arrays.copyOfRange(bucketStart, i, length);

            rx = Arrays.copyOfRange(rx, i, length);

            tx = Arrays.copyOfRange(tx, i, length);

            rxBytes = Arrays.copyOfRange(rxBytes, i, length);

            txBytes = Arrays.copyOfRange(txBytes, i, length);

            bucketCount -= i;

        }

    }
@@ -241,8 +268,8 @@ public class NetworkStatsHistory implements Parcelable { 


            final long overlap = Math.min(curEnd, end) - Math.max(curStart, start);

            if (overlap > 0) {

                rx += this.rx[i] * overlap / bucketDuration;

                tx += this.tx[i] * overlap / bucketDuration;

                rx += this.rxBytes[i] * overlap / bucketDuration;

                tx += this.txBytes[i] * overlap / bucketDuration;

            }

        }
@@ -292,8 +319,8 @@ public class NetworkStatsHistory implements Parcelable { 
        for (int i = start; i < bucketCount; i++) {

            pw.print(prefix);

            pw.print("  bucketStart="); pw.print(bucketStart[i]);

            pw.print(" rx="); pw.print(rx[i]);

            pw.print(" tx="); pw.println(tx[i]);

            pw.print(" rxBytes="); pw.print(rxBytes[i]);

            pw.print(" txBytes="); pw.println(txBytes[i]);

        }

    }

core/tests/coretests/src/android/net/NetworkStatsHistoryTest.java

+55 −49
Original line number Diff line number Diff line
@@ -54,8 +54,8 @@ public class NetworkStatsHistoryTest extends TestCase { 
        // 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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 
        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 @@ public class NetworkStatsHistoryTest extends TestCase { 


        // 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 @@ public class NetworkStatsHistoryTest extends TestCase { 


    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);

    }



}

core/tests/coretests/src/android/net/NetworkStatsTest.java

+55 −59

File changed.

Preview size limit exceeded, changes collapsed.

services/java/com/android/server/ThrottleService.java

+3 −2
Original line number Diff line number Diff line
@@ -515,8 +515,9 @@ public class ThrottleService extends IThrottleManager.Stub { 
                        mIface, NetworkStats.UID_ALL, NetworkStats.TAG_NONE);



                if (index != -1) {

                    incRead = stats.rx[index] - mLastRead;

                    incWrite = stats.tx[index] - mLastWrite;

                    final NetworkStats.Entry entry = stats.getValues(index, null);

                    incRead = entry.rxBytes - mLastRead;

                    incWrite = entry.txBytes - mLastWrite;

                } else {

                    // missing iface, assume stats are 0

                    Slog.w(TAG, "unable to find stats for iface " + mIface);