core/java/android/net/NetworkStatsHistory.java

   1 /*
   2  * Copyright (C) 2011 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.net;
  18
  19 import static android.net.NetworkStats.IFACE_ALL;
  20 import static android.net.NetworkStats.SET_DEFAULT;
  21 import static android.net.NetworkStats.TAG_NONE;
  22 import static android.net.NetworkStats.UID_ALL;
  23 import static android.net.NetworkStatsHistory.DataStreamUtils.readFullLongArray;
  24 import static android.net.NetworkStatsHistory.DataStreamUtils.readVarLongArray;
  25 import static android.net.NetworkStatsHistory.DataStreamUtils.writeVarLongArray;
  26 import static android.net.NetworkStatsHistory.Entry.UNKNOWN;
  27 import static android.net.NetworkStatsHistory.ParcelUtils.readLongArray;
  28 import static android.net.NetworkStatsHistory.ParcelUtils.writeLongArray;
  29 import static android.text.format.DateUtils.SECOND_IN_MILLIS;
  30 import static com.android.internal.util.ArrayUtils.total;
  31
  32 import android.os.Parcel;
  33 import android.os.Parcelable;
  34 import android.util.MathUtils;
  35
  36 import com.android.internal.util.IndentingPrintWriter;
  37
  38 import java.io.CharArrayWriter;
  39 import java.io.DataInputStream;
  40 import java.io.DataOutputStream;
  41 import java.io.IOException;
  42 import java.io.PrintWriter;
  43 import java.net.ProtocolException;
  44 import java.util.Arrays;
  45 import java.util.Random;
  46
  47 /**
  48  * Collection of historical network statistics, recorded into equally-sized
  49  * "buckets" in time. Internally it stores data in {@code long} series for more
  50  * efficient persistence.
  51  * <p>
  52  * Each bucket is defined by a {@link #bucketStart} timestamp, and lasts for
  53  * {@link #bucketDuration}. Internally assumes that {@link #bucketStart} is
  54  * sorted at all times.
  55  *
  56  * @hide
  57  */
  58 public class NetworkStatsHistory implements Parcelable {
  59     private static final int VERSION_INIT = 1;
  60     private static final int VERSION_ADD_PACKETS = 2;
  61     private static final int VERSION_ADD_ACTIVE = 3;
  62
  63     public static final int FIELD_ACTIVE_TIME = 0x01;
  64     public static final int FIELD_RX_BYTES = 0x02;
  65     public static final int FIELD_RX_PACKETS = 0x04;
  66     public static final int FIELD_TX_BYTES = 0x08;
  67     public static final int FIELD_TX_PACKETS = 0x10;
  68     public static final int FIELD_OPERATIONS = 0x20;
  69
  70     public static final int FIELD_ALL = 0xFFFFFFFF;
  71
  72     private long bucketDuration;
  73     private int bucketCount;
  74     private long[] bucketStart;
  75     private long[] activeTime;
  76     private long[] rxBytes;
  77     private long[] rxPackets;
  78     private long[] txBytes;
  79     private long[] txPackets;
  80     private long[] operations;
  81     private long totalBytes;
  82
  83     public static class Entry {
  84         public static final long UNKNOWN = -1;
  85
  86         public long bucketDuration;
  87         public long bucketStart;
  88         public long activeTime;
  89         public long rxBytes;
  90         public long rxPackets;
  91         public long txBytes;
  92         public long txPackets;
  93         public long operations;
  94     }
  95
  96     public NetworkStatsHistory(long bucketDuration) {
  97         this(bucketDuration, 10, FIELD_ALL);
  98     }
  99
 100     public NetworkStatsHistory(long bucketDuration, int initialSize) {
 101         this(bucketDuration, initialSize, FIELD_ALL);
 102     }
 103
 104     public NetworkStatsHistory(long bucketDuration, int initialSize, int fields) {
 105         this.bucketDuration = bucketDuration;
 106         bucketStart = new long[initialSize];
 107         if ((fields & FIELD_ACTIVE_TIME) != 0) activeTime = new long[initialSize];
 108         if ((fields & FIELD_RX_BYTES) != 0) rxBytes = new long[initialSize];
 109         if ((fields & FIELD_RX_PACKETS) != 0) rxPackets = new long[initialSize];
 110         if ((fields & FIELD_TX_BYTES) != 0) txBytes = new long[initialSize];
 111         if ((fields & FIELD_TX_PACKETS) != 0) txPackets = new long[initialSize];
 112         if ((fields & FIELD_OPERATIONS) != 0) operations = new long[initialSize];
 113         bucketCount = 0;
 114         totalBytes = 0;
 115     }
 116
 117     public NetworkStatsHistory(NetworkStatsHistory existing, long bucketDuration) {
 118         this(bucketDuration, existing.estimateResizeBuckets(bucketDuration));
 119         recordEntireHistory(existing);
 120     }
 121
 122     public NetworkStatsHistory(Parcel in) {
 123         bucketDuration = in.readLong();
 124         bucketStart = readLongArray(in);
 125         activeTime = readLongArray(in);
 126         rxBytes = readLongArray(in);
 127         rxPackets = readLongArray(in);
 128         txBytes = readLongArray(in);
 129         txPackets = readLongArray(in);
 130         operations = readLongArray(in);
 131         bucketCount = bucketStart.length;
 132         totalBytes = in.readLong();
 133     }
 134
 135     @Override
 136     public void writeToParcel(Parcel out, int flags) {
 137         out.writeLong(bucketDuration);
 138         writeLongArray(out, bucketStart, bucketCount);
 139         writeLongArray(out, activeTime, bucketCount);
 140         writeLongArray(out, rxBytes, bucketCount);
 141         writeLongArray(out, rxPackets, bucketCount);
 142         writeLongArray(out, txBytes, bucketCount);
 143         writeLongArray(out, txPackets, bucketCount);
 144         writeLongArray(out, operations, bucketCount);
 145         out.writeLong(totalBytes);
 146     }
 147
 148     public NetworkStatsHistory(DataInputStream in) throws IOException {
 149         final int version = in.readInt();
 150         switch (version) {
 151             case VERSION_INIT: {
 152                 bucketDuration = in.readLong();
 153                 bucketStart = readFullLongArray(in);
 154                 rxBytes = readFullLongArray(in);
 155                 rxPackets = new long[bucketStart.length];
 156                 txBytes = readFullLongArray(in);
 157                 txPackets = new long[bucketStart.length];
 158                 operations = new long[bucketStart.length];
 159                 bucketCount = bucketStart.length;
 160                 totalBytes = total(rxBytes) + total(txBytes);
 161                 break;
 162             }
 163             case VERSION_ADD_PACKETS:
 164             case VERSION_ADD_ACTIVE: {
 165                 bucketDuration = in.readLong();
 166                 bucketStart = readVarLongArray(in);
 167                 activeTime = (version >= VERSION_ADD_ACTIVE) ? readVarLongArray(in)
 168                         : new long[bucketStart.length];
 169                 rxBytes = readVarLongArray(in);
 170                 rxPackets = readVarLongArray(in);
 171                 txBytes = readVarLongArray(in);
 172                 txPackets = readVarLongArray(in);
 173                 operations = readVarLongArray(in);
 174                 bucketCount = bucketStart.length;
 175                 totalBytes = total(rxBytes) + total(txBytes);
 176                 break;
 177             }
 178             default: {
 179                 throw new ProtocolException("unexpected version: " + version);
 180             }
 181         }
 182
 183         if (bucketStart.length != bucketCount || rxBytes.length != bucketCount
 184                 || rxPackets.length != bucketCount || txBytes.length != bucketCount
 185                 || txPackets.length != bucketCount || operations.length != bucketCount) {
 186             throw new ProtocolException("Mismatched history lengths");
 187         }
 188     }
 189
 190     public void writeToStream(DataOutputStream out) throws IOException {
 191         out.writeInt(VERSION_ADD_ACTIVE);
 192         out.writeLong(bucketDuration);
 193         writeVarLongArray(out, bucketStart, bucketCount);
 194         writeVarLongArray(out, activeTime, bucketCount);
 195         writeVarLongArray(out, rxBytes, bucketCount);
 196         writeVarLongArray(out, rxPackets, bucketCount);
 197         writeVarLongArray(out, txBytes, bucketCount);
 198         writeVarLongArray(out, txPackets, bucketCount);
 199         writeVarLongArray(out, operations, bucketCount);
 200     }
 201
 202     @Override
 203     public int describeContents() {
 204         return 0;
 205     }
 206
 207     public int size() {
 208         return bucketCount;
 209     }
 210
 211     public long getBucketDuration() {
 212         return bucketDuration;
 213     }
 214
 215     public long getStart() {
 216         if (bucketCount > 0) {
 217             return bucketStart[0];
 218         } else {
 219             return Long.MAX_VALUE;
 220         }
 221     }
 222
 223     public long getEnd() {
 224         if (bucketCount > 0) {
 225             return bucketStart[bucketCount - 1] + bucketDuration;
 226         } else {
 227             return Long.MIN_VALUE;
 228         }
 229     }
 230
 231     /**
 232      * Return total bytes represented by this history.
 233      */
 234     public long getTotalBytes() {
 235         return totalBytes;
 236     }
 237
 238     /**
 239      * Return index of bucket that contains or is immediately before the
 240      * requested time.
 241      */
 242     public int getIndexBefore(long time) {
 243         int index = Arrays.binarySearch(bucketStart, 0, bucketCount, time);
 244         if (index < 0) {
 245             index = (~index) - 1;
 246         } else {
 247             index -= 1;
 248         }
 249         return MathUtils.constrain(index, 0, bucketCount - 1);
 250     }
 251
 252     /**
 253      * Return index of bucket that contains or is immediately after the
 254      * requested time.
 255      */
 256     public int getIndexAfter(long time) {
 257         int index = Arrays.binarySearch(bucketStart, 0, bucketCount, time);
 258         if (index < 0) {
 259             index = ~index;
 260         } else {
 261             index += 1;
 262         }
 263         return MathUtils.constrain(index, 0, bucketCount - 1);
 264     }
 265
 266     /**
 267      * Return specific stats entry.
 268      */
 269     public Entry getValues(int i, Entry recycle) {
 270         final Entry entry = recycle != null ? recycle : new Entry();
 271         entry.bucketStart = bucketStart[i];
 272         entry.bucketDuration = bucketDuration;
 273         entry.activeTime = getLong(activeTime, i, UNKNOWN);
 274         entry.rxBytes = getLong(rxBytes, i, UNKNOWN);
 275         entry.rxPackets = getLong(rxPackets, i, UNKNOWN);
 276         entry.txBytes = getLong(txBytes, i, UNKNOWN);
 277         entry.txPackets = getLong(txPackets, i, UNKNOWN);
 278         entry.operations = getLong(operations, i, UNKNOWN);
 279         return entry;
 280     }
 281
 282     /**
 283      * Record that data traffic occurred in the given time range. Will
 284      * distribute across internal buckets, creating new buckets as needed.
 285      */
 286     @Deprecated
 287     public void recordData(long start, long end, long rxBytes, long txBytes) {
 288         recordData(start, end, new NetworkStats.Entry(
 289                 IFACE_ALL, UID_ALL, SET_DEFAULT, TAG_NONE, rxBytes, 0L, txBytes, 0L, 0L));
 290     }
 291
 292     /**
 293      * Record that data traffic occurred in the given time range. Will
 294      * distribute across internal buckets, creating new buckets as needed.
 295      */
 296     public void recordData(long start, long end, NetworkStats.Entry entry) {
 297         long rxBytes = entry.rxBytes;
 298         long rxPackets = entry.rxPackets;
 299         long txBytes = entry.txBytes;
 300         long txPackets = entry.txPackets;
 301         long operations = entry.operations;
 302
 303         if (entry.isNegative()) {
 304             throw new IllegalArgumentException("tried recording negative data");
 305         }
 306         if (entry.isEmpty()) {
 307             return;
 308         }
 309
 310         // create any buckets needed by this range
 311         ensureBuckets(start, end);
 312
 313         // distribute data usage into buckets
 314         long duration = end - start;
 315         final int startIndex = getIndexAfter(end);
 316         for (int i = startIndex; i >= 0; i--) {
 317             final long curStart = bucketStart[i];
 318             final long curEnd = curStart + bucketDuration;
 319
 320             // bucket is older than record; we're finished
 321             if (curEnd < start) break;
 322             // bucket is newer than record; keep looking
 323             if (curStart > end) continue;
 324
 325             final long overlap = Math.min(curEnd, end) - Math.max(curStart, start);
 326             if (overlap <= 0) continue;
 327
 328             // integer math each time is faster than floating point
 329             final long fracRxBytes = rxBytes * overlap / duration;
 330             final long fracRxPackets = rxPackets * overlap / duration;
 331             final long fracTxBytes = txBytes * overlap / duration;
 332             final long fracTxPackets = txPackets * overlap / duration;
 333             final long fracOperations = operations * overlap / duration;
 334
 335             addLong(activeTime, i, overlap);
 336             addLong(this.rxBytes, i, fracRxBytes); rxBytes -= fracRxBytes;
 337             addLong(this.rxPackets, i, fracRxPackets); rxPackets -= fracRxPackets;
 338             addLong(this.txBytes, i, fracTxBytes); txBytes -= fracTxBytes;
 339             addLong(this.txPackets, i, fracTxPackets); txPackets -= fracTxPackets;
 340             addLong(this.operations, i, fracOperations); operations -= fracOperations;
 341
 342             duration -= overlap;
 343         }
 344
 345         totalBytes += entry.rxBytes + entry.txBytes;
 346     }
 347
 348     /**
 349      * Record an entire {@link NetworkStatsHistory} into this history. Usually
 350      * for combining together stats for external reporting.
 351      */
 352     public void recordEntireHistory(NetworkStatsHistory input) {
 353         recordHistory(input, Long.MIN_VALUE, Long.MAX_VALUE);
 354     }
 355
 356     /**
 357      * Record given {@link NetworkStatsHistory} into this history, copying only
 358      * buckets that atomically occur in the inclusive time range. Doesn't
 359      * interpolate across partial buckets.
 360      */
 361     public void recordHistory(NetworkStatsHistory input, long start, long end) {
 362         final NetworkStats.Entry entry = new NetworkStats.Entry(
 363                 IFACE_ALL, UID_ALL, SET_DEFAULT, TAG_NONE, 0L, 0L, 0L, 0L, 0L);
 364         for (int i = 0; i < input.bucketCount; i++) {
 365             final long bucketStart = input.bucketStart[i];
 366             final long bucketEnd = bucketStart + input.bucketDuration;
 367
 368             // skip when bucket is outside requested range
 369             if (bucketStart < start || bucketEnd > end) continue;
 370
 371             entry.rxBytes = getLong(input.rxBytes, i, 0L);
 372             entry.rxPackets = getLong(input.rxPackets, i, 0L);
 373             entry.txBytes = getLong(input.txBytes, i, 0L);
 374             entry.txPackets = getLong(input.txPackets, i, 0L);
 375             entry.operations = getLong(input.operations, i, 0L);
 376
 377             recordData(bucketStart, bucketEnd, entry);
 378         }
 379     }
 380
 381     /**
 382      * Ensure that buckets exist for given time range, creating as needed.
 383      */
 384     private void ensureBuckets(long start, long end) {
 385         // normalize incoming range to bucket boundaries
 386         start -= start % bucketDuration;
 387         end += (bucketDuration - (end % bucketDuration)) % bucketDuration;
 388
 389         for (long now = start; now < end; now += bucketDuration) {
 390             // try finding existing bucket
 391             final int index = Arrays.binarySearch(bucketStart, 0, bucketCount, now);
 392             if (index < 0) {
 393                 // bucket missing, create and insert
 394                 insertBucket(~index, now);
 395             }
 396         }
 397     }
 398
 399     /**
 400      * Insert new bucket at requested index and starting time.
 401      */
 402     private void insertBucket(int index, long start) {
 403         // create more buckets when needed
 404         if (bucketCount >= bucketStart.length) {
 405             final int newLength = Math.max(bucketStart.length, 10) * 3 / 2;
 406             bucketStart = Arrays.copyOf(bucketStart, newLength);
 407             if (activeTime != null) activeTime = Arrays.copyOf(activeTime, newLength);
 408             if (rxBytes != null) rxBytes = Arrays.copyOf(rxBytes, newLength);
 409             if (rxPackets != null) rxPackets = Arrays.copyOf(rxPackets, newLength);
 410             if (txBytes != null) txBytes = Arrays.copyOf(txBytes, newLength);
 411             if (txPackets != null) txPackets = Arrays.copyOf(txPackets, newLength);
 412             if (operations != null) operations = Arrays.copyOf(operations, newLength);
 413         }
 414
 415         // create gap when inserting bucket in middle
 416         if (index < bucketCount) {
 417             final int dstPos = index + 1;
 418             final int length = bucketCount - index;
 419
 420             System.arraycopy(bucketStart, index, bucketStart, dstPos, length);
 421             if (activeTime != null) System.arraycopy(activeTime, index, activeTime, dstPos, length);
 422             if (rxBytes != null) System.arraycopy(rxBytes, index, rxBytes, dstPos, length);
 423             if (rxPackets != null) System.arraycopy(rxPackets, index, rxPackets, dstPos, length);
 424             if (txBytes != null) System.arraycopy(txBytes, index, txBytes, dstPos, length);
 425             if (txPackets != null) System.arraycopy(txPackets, index, txPackets, dstPos, length);
 426             if (operations != null) System.arraycopy(operations, index, operations, dstPos, length);
 427         }
 428
 429         bucketStart[index] = start;
 430         setLong(activeTime, index, 0L);
 431         setLong(rxBytes, index, 0L);
 432         setLong(rxPackets, index, 0L);
 433         setLong(txBytes, index, 0L);
 434         setLong(txPackets, index, 0L);
 435         setLong(operations, index, 0L);
 436         bucketCount++;
 437     }
 438
 439     /**
 440      * Remove buckets older than requested cutoff.
 441      */
 442     @Deprecated
 443     public void removeBucketsBefore(long cutoff) {
 444         int i;
 445         for (i = 0; i < bucketCount; i++) {
 446             final long curStart = bucketStart[i];
 447             final long curEnd = curStart + bucketDuration;
 448
 449             // cutoff happens before or during this bucket; everything before
 450             // this bucket should be removed.
 451             if (curEnd > cutoff) break;
 452         }
 453
 454         if (i > 0) {
 455             final int length = bucketStart.length;
 456             bucketStart = Arrays.copyOfRange(bucketStart, i, length);
 457             if (activeTime != null) activeTime = Arrays.copyOfRange(activeTime, i, length);
 458             if (rxBytes != null) rxBytes = Arrays.copyOfRange(rxBytes, i, length);
 459             if (rxPackets != null) rxPackets = Arrays.copyOfRange(rxPackets, i, length);
 460             if (txBytes != null) txBytes = Arrays.copyOfRange(txBytes, i, length);
 461             if (txPackets != null) txPackets = Arrays.copyOfRange(txPackets, i, length);
 462             if (operations != null) operations = Arrays.copyOfRange(operations, i, length);
 463             bucketCount -= i;
 464
 465             // TODO: subtract removed values from totalBytes
 466         }
 467     }
 468
 469     /**
 470      * Return interpolated data usage across the requested range. Interpolates
 471      * across buckets, so values may be rounded slightly.
 472      */
 473     public Entry getValues(long start, long end, Entry recycle) {
 474         return getValues(start, end, Long.MAX_VALUE, recycle);
 475     }
 476
 477     /**
 478      * Return interpolated data usage across the requested range. Interpolates
 479      * across buckets, so values may be rounded slightly.
 480      */
 481     public Entry getValues(long start, long end, long now, Entry recycle) {
 482         final Entry entry = recycle != null ? recycle : new Entry();
 483         entry.bucketDuration = end - start;
 484         entry.bucketStart = start;
 485         entry.activeTime = activeTime != null ? 0 : UNKNOWN;
 486         entry.rxBytes = rxBytes != null ? 0 : UNKNOWN;
 487         entry.rxPackets = rxPackets != null ? 0 : UNKNOWN;
 488         entry.txBytes = txBytes != null ? 0 : UNKNOWN;
 489         entry.txPackets = txPackets != null ? 0 : UNKNOWN;
 490         entry.operations = operations != null ? 0 : UNKNOWN;
 491
 492         final int startIndex = getIndexAfter(end);
 493         for (int i = startIndex; i >= 0; i--) {
 494             final long curStart = bucketStart[i];
 495             final long curEnd = curStart + bucketDuration;
 496
 497             // bucket is older than request; we're finished
 498             if (curEnd <= start) break;
 499             // bucket is newer than request; keep looking
 500             if (curStart >= end) continue;
 501
 502             // include full value for active buckets, otherwise only fractional
 503             final boolean activeBucket = curStart < now && curEnd > now;
 504             final long overlap;
 505             if (activeBucket) {
 506                 overlap = bucketDuration;
 507             } else {
 508                 final long overlapEnd = curEnd < end ? curEnd : end;
 509                 final long overlapStart = curStart > start ? curStart : start;
 510                 overlap = overlapEnd - overlapStart;
 511             }
 512             if (overlap <= 0) continue;
 513
 514             // integer math each time is faster than floating point
 515             if (activeTime != null) entry.activeTime += activeTime[i] * overlap / bucketDuration;
 516             if (rxBytes != null) entry.rxBytes += rxBytes[i] * overlap / bucketDuration;
 517             if (rxPackets != null) entry.rxPackets += rxPackets[i] * overlap / bucketDuration;
 518             if (txBytes != null) entry.txBytes += txBytes[i] * overlap / bucketDuration;
 519             if (txPackets != null) entry.txPackets += txPackets[i] * overlap / bucketDuration;
 520             if (operations != null) entry.operations += operations[i] * overlap / bucketDuration;
 521         }
 522         return entry;
 523     }
 524
 525     /**
 526      * @deprecated only for temporary testing
 527      */
 528     @Deprecated
 529     public void generateRandom(long start, long end, long bytes) {
 530         final Random r = new Random();
 531
 532         final float fractionRx = r.nextFloat();
 533         final long rxBytes = (long) (bytes * fractionRx);
 534         final long txBytes = (long) (bytes * (1 - fractionRx));
 535
 536         final long rxPackets = rxBytes / 1024;
 537         final long txPackets = txBytes / 1024;
 538         final long operations = rxBytes / 2048;
 539
 540         generateRandom(start, end, rxBytes, rxPackets, txBytes, txPackets, operations, r);
 541     }
 542
 543     /**
 544      * @deprecated only for temporary testing
 545      */
 546     @Deprecated
 547     public void generateRandom(long start, long end, long rxBytes, long rxPackets, long txBytes,
 548             long txPackets, long operations, Random r) {
 549         ensureBuckets(start, end);
 550
 551         final NetworkStats.Entry entry = new NetworkStats.Entry(
 552                 IFACE_ALL, UID_ALL, SET_DEFAULT, TAG_NONE, 0L, 0L, 0L, 0L, 0L);
 553         while (rxBytes > 1024 || rxPackets > 128 || txBytes > 1024 || txPackets > 128
 554                 || operations > 32) {
 555             final long curStart = randomLong(r, start, end);
 556             final long curEnd = curStart + randomLong(r, 0, (end - curStart) / 2);
 557
 558             entry.rxBytes = randomLong(r, 0, rxBytes);
 559             entry.rxPackets = randomLong(r, 0, rxPackets);
 560             entry.txBytes = randomLong(r, 0, txBytes);
 561             entry.txPackets = randomLong(r, 0, txPackets);
 562             entry.operations = randomLong(r, 0, operations);
 563
 564             rxBytes -= entry.rxBytes;
 565             rxPackets -= entry.rxPackets;
 566             txBytes -= entry.txBytes;
 567             txPackets -= entry.txPackets;
 568             operations -= entry.operations;
 569
 570             recordData(curStart, curEnd, entry);
 571         }
 572     }
 573
 574     public static long randomLong(Random r, long start, long end) {
 575         return (long) (start + (r.nextFloat() * (end - start)));
 576     }
 577
 578     /**
 579      * Quickly determine if this history intersects with given window.
 580      */
 581     public boolean intersects(long start, long end) {
 582         final long dataStart = getStart();
 583         final long dataEnd = getEnd();
 584         if (start >= dataStart && start <= dataEnd) return true;
 585         if (end >= dataStart && end <= dataEnd) return true;
 586         if (dataStart >= start && dataStart <= end) return true;
 587         if (dataEnd >= start && dataEnd <= end) return true;
 588         return false;
 589     }
 590
 591     public void dump(IndentingPrintWriter pw, boolean fullHistory) {
 592         pw.print("NetworkStatsHistory: bucketDuration=");
 593         pw.println(bucketDuration / SECOND_IN_MILLIS);
 594         pw.increaseIndent();
 595
 596         final int start = fullHistory ? 0 : Math.max(0, bucketCount - 32);
 597         if (start > 0) {
 598             pw.print("(omitting "); pw.print(start); pw.println(" buckets)");
 599         }
 600
 601         for (int i = start; i < bucketCount; i++) {
 602             pw.print("st="); pw.print(bucketStart[i] / SECOND_IN_MILLIS);
 603             if (rxBytes != null) { pw.print(" rb="); pw.print(rxBytes[i]); }
 604             if (rxPackets != null) { pw.print(" rp="); pw.print(rxPackets[i]); }
 605             if (txBytes != null) { pw.print(" tb="); pw.print(txBytes[i]); }
 606             if (txPackets != null) { pw.print(" tp="); pw.print(txPackets[i]); }
 607             if (operations != null) { pw.print(" op="); pw.print(operations[i]); }
 608             pw.println();
 609         }
 610
 611         pw.decreaseIndent();
 612     }
 613
 614     public void dumpCheckin(PrintWriter pw) {
 615         pw.print("d,");
 616         pw.print(bucketDuration / SECOND_IN_MILLIS);
 617         pw.println();
 618
 619         for (int i = 0; i < bucketCount; i++) {
 620             pw.print("b,");
 621             pw.print(bucketStart[i] / SECOND_IN_MILLIS); pw.print(',');
 622             if (rxBytes != null) { pw.print(rxBytes[i]); } else { pw.print("*"); } pw.print(',');
 623             if (rxPackets != null) { pw.print(rxPackets[i]); } else { pw.print("*"); } pw.print(',');
 624             if (txBytes != null) { pw.print(txBytes[i]); } else { pw.print("*"); } pw.print(',');
 625             if (txPackets != null) { pw.print(txPackets[i]); } else { pw.print("*"); } pw.print(',');
 626             if (operations != null) { pw.print(operations[i]); } else { pw.print("*"); }
 627             pw.println();
 628         }
 629     }
 630
 631     @Override
 632     public String toString() {
 633         final CharArrayWriter writer = new CharArrayWriter();
 634         dump(new IndentingPrintWriter(writer, "  "), false);
 635         return writer.toString();
 636     }
 637
 638     public static final Creator<NetworkStatsHistory> CREATOR = new Creator<NetworkStatsHistory>() {
 639         @Override
 640         public NetworkStatsHistory createFromParcel(Parcel in) {
 641             return new NetworkStatsHistory(in);
 642         }
 643
 644         @Override
 645         public NetworkStatsHistory[] newArray(int size) {
 646             return new NetworkStatsHistory[size];
 647         }
 648     };
 649
 650     private static long getLong(long[] array, int i, long value) {
 651         return array != null ? array[i] : value;
 652     }
 653
 654     private static void setLong(long[] array, int i, long value) {
 655         if (array != null) array[i] = value;
 656     }
 657
 658     private static void addLong(long[] array, int i, long value) {
 659         if (array != null) array[i] += value;
 660     }
 661
 662     public int estimateResizeBuckets(long newBucketDuration) {
 663         return (int) (size() * getBucketDuration() / newBucketDuration);
 664     }
 665
 666     /**
 667      * Utility methods for interacting with {@link DataInputStream} and
 668      * {@link DataOutputStream}, mostly dealing with writing partial arrays.
 669      */
 670     public static class DataStreamUtils {
 671         @Deprecated
 672         public static long[] readFullLongArray(DataInputStream in) throws IOException {
 673             final int size = in.readInt();
 674             if (size < 0) throw new ProtocolException("negative array size");
 675             final long[] values = new long[size];
 676             for (int i = 0; i < values.length; i++) {
 677                 values[i] = in.readLong();
 678             }
 679             return values;
 680         }
 681
 682         /**
 683          * Read variable-length {@link Long} using protobuf-style approach.
 684          */
 685         public static long readVarLong(DataInputStream in) throws IOException {
 686             int shift = 0;
 687             long result = 0;
 688             while (shift < 64) {
 689                 byte b = in.readByte();
 690                 result |= (long) (b & 0x7F) << shift;
 691                 if ((b & 0x80) == 0)
 692                     return result;
 693                 shift += 7;
 694             }
 695             throw new ProtocolException("malformed long");
 696         }
 697
 698         /**
 699          * Write variable-length {@link Long} using protobuf-style approach.
 700          */
 701         public static void writeVarLong(DataOutputStream out, long value) throws IOException {
 702             while (true) {
 703                 if ((value & ~0x7FL) == 0) {
 704                     out.writeByte((int) value);
 705                     return;
 706                 } else {
 707                     out.writeByte(((int) value & 0x7F) | 0x80);
 708                     value >>>= 7;
 709                 }
 710             }
 711         }
 712
 713         public static long[] readVarLongArray(DataInputStream in) throws IOException {
 714             final int size = in.readInt();
 715             if (size == -1) return null;
 716             if (size < 0) throw new ProtocolException("negative array size");
 717             final long[] values = new long[size];
 718             for (int i = 0; i < values.length; i++) {
 719                 values[i] = readVarLong(in);
 720             }
 721             return values;
 722         }
 723
 724         public static void writeVarLongArray(DataOutputStream out, long[] values, int size)
 725                 throws IOException {
 726             if (values == null) {
 727                 out.writeInt(-1);
 728                 return;
 729             }
 730             if (size > values.length) {
 731                 throw new IllegalArgumentException("size larger than length");
 732             }
 733             out.writeInt(size);
 734             for (int i = 0; i < size; i++) {
 735                 writeVarLong(out, values[i]);
 736             }
 737         }
 738     }
 739
 740     /**
 741      * Utility methods for interacting with {@link Parcel} structures, mostly
 742      * dealing with writing partial arrays.
 743      */
 744     public static class ParcelUtils {
 745         public static long[] readLongArray(Parcel in) {
 746             final int size = in.readInt();
 747             if (size == -1) return null;
 748             final long[] values = new long[size];
 749             for (int i = 0; i < values.length; i++) {
 750                 values[i] = in.readLong();
 751             }
 752             return values;
 753         }
 754
 755         public static void writeLongArray(Parcel out, long[] values, int size) {
 756             if (values == null) {
 757                 out.writeInt(-1);
 758                 return;
 759             }
 760             if (size > values.length) {
 761                 throw new IllegalArgumentException("size larger than length");
 762             }
 763             out.writeInt(size);
 764             for (int i = 0; i < size; i++) {
 765                 out.writeLong(values[i]);
 766             }
 767         }
 768     }
 769
 770 }