Modify TelephonyHistogram.java functions.
+ Update getBucketEndPoints & getBucketCounters to return values even when
sampleCount < 10.
Bug: 28717269
Change-Id: Ie3d16d472d04f051442d22bbe0f9f63dece8cc46
diff --git a/telephony/java/android/telephony/TelephonyHistogram.java b/telephony/java/android/telephony/TelephonyHistogram.java
index 9d9ce72..e1c3d7b 100644
--- a/telephony/java/android/telephony/TelephonyHistogram.java
+++ b/telephony/java/android/telephony/TelephonyHistogram.java
@@ -31,35 +31,35 @@
public final class TelephonyHistogram implements Parcelable {
// Type of Telephony histogram Eg: RIL histogram will have all timing data associated with
// RIL calls. Similarly we can have any other Telephony histogram.
- private final int category;
+ private final int mCategory;
// Unique Id identifying a sample within particular category of histogram
- private final int id;
+ private final int mId;
// Min time taken in ms
- private int minTimeMs;
+ private int mMinTimeMs;
// Max time taken in ms
- private int maxTimeMs;
+ private int mMaxTimeMs;
// Average time taken in ms
- private int averageTimeMs;
+ private int mAverageTimeMs;
// Total count of samples
- private int sampleCount;
+ private int mSampleCount;
// Array storing time taken for first #RANGE_CALCULATION_COUNT samples of histogram.
- private int[] initialTimings;
+ private int[] mInitialTimings;
// Total number of time ranges expected (must be greater than 1)
- private final int bucketCount;
+ private final int mBucketCount;
// Array storing endpoints of range buckets. Calculated based on values of minTime & maxTime
// after totalTimeCount is #RANGE_CALCULATION_COUNT.
- private final int[] bucketEndPoints;
+ private final int[] mBucketEndPoints;
// Array storing counts for each time range starting from smallest value range
- private final int[] bucketCounters;
+ private final int[] mBucketCounters;
/**
* Constant for Telephony category
@@ -81,69 +81,85 @@
if (bucketCount <= 1) {
throw new IllegalArgumentException("Invalid number of buckets");
}
- this.category = category;
- this.id = id;
- this.minTimeMs = Integer.MAX_VALUE;
- this.maxTimeMs = 0;
- this.averageTimeMs = 0;
- this.sampleCount = 0;
- initialTimings = new int[RANGE_CALCULATION_COUNT];
- this.bucketCount = bucketCount;
- bucketEndPoints = new int[bucketCount - 1];
- bucketCounters = new int[bucketCount];
+ mCategory = category;
+ mId = id;
+ mMinTimeMs = Integer.MAX_VALUE;
+ mMaxTimeMs = 0;
+ mAverageTimeMs = 0;
+ mSampleCount = 0;
+ mInitialTimings = new int[RANGE_CALCULATION_COUNT];
+ mBucketCount = bucketCount;
+ mBucketEndPoints = new int[bucketCount - 1];
+ mBucketCounters = new int[bucketCount];
}
public TelephonyHistogram(TelephonyHistogram th) {
- category = th.getCategory();
- id = th.getId();
- minTimeMs = th.getMinTime();
- maxTimeMs = th.getMaxTime();
- averageTimeMs = th.getAverageTime();
- sampleCount = th.getSampleCount();
- initialTimings = th.getInitialTimings();
- bucketCount = th.getBucketCount();
- bucketEndPoints = th.getBucketEndPoints();
- bucketCounters = th.getBucketCounters();
+ mCategory = th.getCategory();
+ mId = th.getId();
+ mMinTimeMs = th.getMinTime();
+ mMaxTimeMs = th.getMaxTime();
+ mAverageTimeMs = th.getAverageTime();
+ mSampleCount = th.getSampleCount();
+ mInitialTimings = th.getInitialTimings();
+ mBucketCount = th.getBucketCount();
+ mBucketEndPoints = th.getBucketEndPoints();
+ mBucketCounters = th.getBucketCounters();
}
public int getCategory() {
- return category;
+ return mCategory;
}
public int getId() {
- return id;
+ return mId;
}
public int getMinTime() {
- return minTimeMs;
+ return mMinTimeMs;
}
public int getMaxTime() {
- return maxTimeMs;
+ return mMaxTimeMs;
}
public int getAverageTime() {
- return averageTimeMs;
+ return mAverageTimeMs;
}
public int getSampleCount () {
- return sampleCount;
+ return mSampleCount;
}
private int[] getInitialTimings() {
- return initialTimings;
+ return mInitialTimings;
}
public int getBucketCount() {
- return bucketCount;
+ return mBucketCount;
}
public int[] getBucketEndPoints() {
- return getDeepCopyOfArray(bucketEndPoints);
+ if (mSampleCount > 1 && mSampleCount < 10) {
+ int[] tempEndPoints = new int[mBucketCount - 1];
+ calculateBucketEndPoints(tempEndPoints);
+ return tempEndPoints;
+ } else {
+ return getDeepCopyOfArray(mBucketEndPoints);
+ }
}
public int[] getBucketCounters() {
- return getDeepCopyOfArray(bucketCounters);
+ if (mSampleCount > 1 && mSampleCount < 10) {
+ int[] tempEndPoints = new int[mBucketCount - 1];
+ int[] tempBucketCounters = new int[mBucketCount];
+ calculateBucketEndPoints(tempEndPoints);
+ for (int j = 0; j < mSampleCount; j++) {
+ addToBucketCounter(tempEndPoints, tempBucketCounters, mInitialTimings[j]);
+ }
+ return tempBucketCounters;
+ } else {
+ return getDeepCopyOfArray(mBucketCounters);
+ }
}
private int[] getDeepCopyOfArray(int[] array) {
@@ -152,7 +168,7 @@
return clone;
}
- private void addToBucketCounter(int time) {
+ private void addToBucketCounter(int[] bucketEndPoints, int[] bucketCounters, int time) {
int i;
for (i = 0; i < bucketEndPoints.length; i++) {
if (time <= bucketEndPoints[i]) {
@@ -163,6 +179,13 @@
bucketCounters[i]++;
}
+ private void calculateBucketEndPoints(int[] bucketEndPoints) {
+ for (int i = 1; i < mBucketCount; i++) {
+ int endPt = mMinTimeMs + (i * (mMaxTimeMs - mMinTimeMs)) / mBucketCount;
+ bucketEndPoints[i - 1] = endPt;
+ }
+ }
+
// Add new value of time taken
// This function updates minTime, maxTime, averageTime & totalTimeCount every time it is
// called. initialTimings[] is updated if totalTimeCount <= #RANGE_CALCULATION_COUNT. When
@@ -172,65 +195,62 @@
public void addTimeTaken(int time) {
// Initialize all fields if its first entry or if integer overflow is going to occur while
// trying to calculate averageTime
- if (sampleCount == 0 || (sampleCount == Integer.MAX_VALUE)) {
- if (sampleCount == 0) {
- minTimeMs = time;
- maxTimeMs = time;
- averageTimeMs = time;
+ if (mSampleCount == 0 || (mSampleCount == Integer.MAX_VALUE)) {
+ if (mSampleCount == 0) {
+ mMinTimeMs = time;
+ mMaxTimeMs = time;
+ mAverageTimeMs = time;
} else {
- initialTimings = new int[RANGE_CALCULATION_COUNT];
+ mInitialTimings = new int[RANGE_CALCULATION_COUNT];
}
- sampleCount = 1;
- Arrays.fill(initialTimings, 0);
- initialTimings[0] = time;
- Arrays.fill(bucketEndPoints, 0);
- Arrays.fill(bucketCounters, 0);
+ mSampleCount = 1;
+ Arrays.fill(mInitialTimings, 0);
+ mInitialTimings[0] = time;
+ Arrays.fill(mBucketEndPoints, 0);
+ Arrays.fill(mBucketCounters, 0);
} else {
- if (time < minTimeMs) {
- minTimeMs = time;
+ if (time < mMinTimeMs) {
+ mMinTimeMs = time;
}
- if (time > maxTimeMs) {
- maxTimeMs = time;
+ if (time > mMaxTimeMs) {
+ mMaxTimeMs = time;
}
- long totalTime = ((long)averageTimeMs) * sampleCount + time;
- averageTimeMs = (int)(totalTime/++sampleCount);
+ long totalTime = ((long)mAverageTimeMs) * mSampleCount + time;
+ mAverageTimeMs = (int)(totalTime/++mSampleCount);
- if (sampleCount < RANGE_CALCULATION_COUNT) {
- initialTimings[sampleCount - 1] = time;
- } else if (sampleCount == RANGE_CALCULATION_COUNT) {
- initialTimings[sampleCount - 1] = time;
+ if (mSampleCount < RANGE_CALCULATION_COUNT) {
+ mInitialTimings[mSampleCount - 1] = time;
+ } else if (mSampleCount == RANGE_CALCULATION_COUNT) {
+ mInitialTimings[mSampleCount - 1] = time;
// Calculate bucket endpoints based on bucketCount expected
- for (int i = 1; i < bucketCount; i++) {
- int endPt = minTimeMs + (i * (maxTimeMs - minTimeMs)) / bucketCount;
- bucketEndPoints[i - 1] = endPt;
- }
+ calculateBucketEndPoints(mBucketEndPoints);
// Use values stored in initialTimings[] to update bucketCounters
for (int j = 0; j < RANGE_CALCULATION_COUNT; j++) {
- addToBucketCounter(initialTimings[j]);
+ addToBucketCounter(mBucketEndPoints, mBucketCounters, mInitialTimings[j]);
}
- initialTimings = null;
+ mInitialTimings = null;
} else {
- addToBucketCounter(time);
+ addToBucketCounter(mBucketEndPoints, mBucketCounters, time);
}
}
}
public String toString() {
- String basic = " Histogram id = " + id + " Time(ms): min = " + minTimeMs + " max = "
- + maxTimeMs + " avg = " + averageTimeMs + " Count = " + sampleCount;
- if (sampleCount < RANGE_CALCULATION_COUNT) {
+ String basic = " Histogram id = " + mId + " Time(ms): min = " + mMinTimeMs + " max = "
+ + mMaxTimeMs + " avg = " + mAverageTimeMs + " Count = " + mSampleCount;
+ if (mSampleCount < RANGE_CALCULATION_COUNT) {
return basic;
} else {
StringBuffer intervals = new StringBuffer(" Interval Endpoints:");
- for (int i = 0; i < bucketEndPoints.length; i++) {
- intervals.append(" " + bucketEndPoints[i]);
+ for (int i = 0; i < mBucketEndPoints.length; i++) {
+ intervals.append(" " + mBucketEndPoints[i]);
}
intervals.append(" Interval counters:");
- for (int i = 0; i < bucketCounters.length; i++) {
- intervals.append(" " + bucketCounters[i]);
+ for (int i = 0; i < mBucketCounters.length; i++) {
+ intervals.append(" " + mBucketCounters[i]);
}
return basic + intervals;
}
@@ -251,39 +271,39 @@
};
public TelephonyHistogram(Parcel in) {
- category = in.readInt();
- id = in.readInt();
- minTimeMs = in.readInt();
- maxTimeMs = in.readInt();
- averageTimeMs = in.readInt();
- sampleCount = in.readInt();
+ mCategory = in.readInt();
+ mId = in.readInt();
+ mMinTimeMs = in.readInt();
+ mMaxTimeMs = in.readInt();
+ mAverageTimeMs = in.readInt();
+ mSampleCount = in.readInt();
if (in.readInt() == PRESENT) {
- initialTimings = new int[RANGE_CALCULATION_COUNT];
- in.readIntArray(initialTimings);
+ mInitialTimings = new int[RANGE_CALCULATION_COUNT];
+ in.readIntArray(mInitialTimings);
}
- bucketCount = in.readInt();
- bucketEndPoints = new int[bucketCount - 1];
- in.readIntArray(bucketEndPoints);
- bucketCounters = new int[bucketCount];
- in.readIntArray(bucketCounters);
+ mBucketCount = in.readInt();
+ mBucketEndPoints = new int[mBucketCount - 1];
+ in.readIntArray(mBucketEndPoints);
+ mBucketCounters = new int[mBucketCount];
+ in.readIntArray(mBucketCounters);
}
public void writeToParcel(Parcel out, int flags) {
- out.writeInt(category);
- out.writeInt(id);
- out.writeInt(minTimeMs);
- out.writeInt(maxTimeMs);
- out.writeInt(averageTimeMs);
- out.writeInt(sampleCount);
- if (initialTimings == null) {
+ out.writeInt(mCategory);
+ out.writeInt(mId);
+ out.writeInt(mMinTimeMs);
+ out.writeInt(mMaxTimeMs);
+ out.writeInt(mAverageTimeMs);
+ out.writeInt(mSampleCount);
+ if (mInitialTimings == null) {
out.writeInt(ABSENT);
} else {
out.writeInt(PRESENT);
- out.writeIntArray(initialTimings);
+ out.writeIntArray(mInitialTimings);
}
- out.writeInt(bucketCount);
- out.writeIntArray(bucketEndPoints);
- out.writeIntArray(bucketCounters);
+ out.writeInt(mBucketCount);
+ out.writeIntArray(mBucketEndPoints);
+ out.writeIntArray(mBucketCounters);
}
@Override
