From 02b4cf2aca2a9e2de84f54a8b232455a49faa7c1 Mon Sep 17 00:00:00 2001 From: Doris Ling Date: Wed, 28 Mar 2018 17:14:23 -0700 Subject: [PATCH] Report unavailable data usage. - when showing the data usage graph, if the first data point is equal to the first available data, insert a 0 usage point on the first day of available data, so that it will show a flat line for the days that do not have available data instead of showing a non-zero slope. Change-Id: Ibf305e292a65ab3310ea12efbb575e3a7e1b6012 Fixes: 76155147 Test: make RunSettingsRoboTests --- .../datausage/ChartDataUsagePreference.java | 7 +- .../android/settings/graph/UsageGraph.java | 4 + .../ChartDataUsagePreferenceTest.java | 129 ++++++++++++++++++ .../settings/graph/UsageGraphTest.java | 36 ++++- 4 files changed, 171 insertions(+), 5 deletions(-) create mode 100644 tests/robotests/src/com/android/settings/datausage/ChartDataUsagePreferenceTest.java diff --git a/src/com/android/settings/datausage/ChartDataUsagePreference.java b/src/com/android/settings/datausage/ChartDataUsagePreference.java index 3c3a231f167..a6d04b65174 100644 --- a/src/com/android/settings/datausage/ChartDataUsagePreference.java +++ b/src/com/android/settings/datausage/ChartDataUsagePreference.java @@ -18,6 +18,7 @@ import android.content.Context; import android.net.NetworkPolicy; import android.net.NetworkStatsHistory; import android.net.TrafficStats; +import android.support.annotation.VisibleForTesting; import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceViewHolder; import android.text.SpannableStringBuilder; @@ -88,7 +89,8 @@ public class ChartDataUsagePreference extends Preference { return (int) (Math.max(totalData, policyMax) / RESOLUTION); } - private void calcPoints(UsageView chart) { + @VisibleForTesting + void calcPoints(UsageView chart) { SparseIntArray points = new SparseIntArray(); NetworkStatsHistory.Entry entry = null; @@ -108,6 +110,9 @@ public class ChartDataUsagePreference extends Preference { // increment by current bucket total totalData += entry.rxBytes + entry.txBytes; + if (i == 0) { + points.put(toInt(startTime - mStart) - 1, -1); + } points.put(toInt(startTime - mStart + 1), (int) (totalData / RESOLUTION)); points.put(toInt(endTime - mStart), (int) (totalData / RESOLUTION)); } diff --git a/src/com/android/settings/graph/UsageGraph.java b/src/com/android/settings/graph/UsageGraph.java index a39cb43e27b..db13338bc6f 100644 --- a/src/com/android/settings/graph/UsageGraph.java +++ b/src/com/android/settings/graph/UsageGraph.java @@ -185,6 +185,10 @@ public class UsageGraph extends View { int x = paths.keyAt(i); int y = paths.valueAt(i); if (y == PATH_DELIM) { + if (i == 1) { + localPaths.put(getX(x+1) - 1, getY(0)); + continue; + } if (i == paths.size() - 1 && skippedLastPoint) { // Add back skipped point to complete the path. localPaths.put(lx, ly); diff --git a/tests/robotests/src/com/android/settings/datausage/ChartDataUsagePreferenceTest.java b/tests/robotests/src/com/android/settings/datausage/ChartDataUsagePreferenceTest.java new file mode 100644 index 00000000000..541aeae509e --- /dev/null +++ b/tests/robotests/src/com/android/settings/datausage/ChartDataUsagePreferenceTest.java @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ +package com.android.settings.datausage; + +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.net.NetworkStatsHistory; +import android.net.NetworkStatsHistory.Entry; +import android.util.SparseIntArray; +import com.android.settings.graph.UsageView; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class ChartDataUsagePreferenceTest { + + private static final long MILLIS_IN_ONE_HOUR = 60 * 60 * 1000; + private static final long MILLIS_IN_ONE_DAY = 24 * MILLIS_IN_ONE_HOUR; + + private NetworkStatsHistory mNetworkStatsHistory; + private Context mContext; + private ChartDataUsagePreference mPreference; + private long mNow; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = RuntimeEnvironment.application; + mPreference = new ChartDataUsagePreference(mContext, null); + mNow = System.currentTimeMillis(); + mNetworkStatsHistory = spy(new NetworkStatsHistory(MILLIS_IN_ONE_HOUR, 10)); + addTestNetworkEntries(); + mPreference.setNetworkStats(mNetworkStatsHistory); + } + + @Test + public void calcPoints_notStartOfData_shouldAddDataPointsOnly() { + final long start = mNow - 20 * MILLIS_IN_ONE_DAY; + final long end = mNow - 5 * MILLIS_IN_ONE_DAY; + mPreference.setVisibleRange(start, end); + when(mNetworkStatsHistory.getIndexAfter(start)).thenReturn(2); + when(mNetworkStatsHistory.getIndexAfter(end)).thenReturn(7); + final UsageView usageView = mock(UsageView.class); + final ArgumentCaptor pointsCaptor = + ArgumentCaptor.forClass(SparseIntArray.class); + + mPreference.calcPoints(usageView); + + verify(usageView).addPath(pointsCaptor.capture()); + SparseIntArray points = pointsCaptor.getValue(); + // the point should be normal usage data + assertThat(points.valueAt(1)).isNotEqualTo(-1); + } + + @Test + public void calcPoints_startOfData_shouldIndicateStartOfData() { + final long start = mNow - 20 * MILLIS_IN_ONE_DAY; + final long end = mNow - 5 * MILLIS_IN_ONE_DAY; + mPreference.setVisibleRange(start, end); + when(mNetworkStatsHistory.getIndexAfter(start)).thenReturn(0); + when(mNetworkStatsHistory.getIndexAfter(end)).thenReturn(5); + final UsageView usageView = mock(UsageView.class); + final ArgumentCaptor pointsCaptor = + ArgumentCaptor.forClass(SparseIntArray.class); + + mPreference.calcPoints(usageView); + + verify(usageView).addPath(pointsCaptor.capture()); + SparseIntArray points = pointsCaptor.getValue(); + // indicator that no data is available + assertThat(points.keyAt(1)).isEqualTo(points.keyAt(2) - 1); + assertThat(points.valueAt(1)).isEqualTo(-1); + } + + private void addTestNetworkEntries() { + // create 10 arbitary network data + mNetworkStatsHistory.setValues(0, createEntry(1521583200000L, 743823454L, 16574289L)); + mNetworkStatsHistory.setValues(1, createEntry(1521586800000L, 64396L, 160364L)); + mNetworkStatsHistory.setValues(2, createEntry(1521590400000L, 2832L, 5299L)); + mNetworkStatsHistory.setValues(3, createEntry(1521655200000L, 83849690L, 3558238L)); + mNetworkStatsHistory.setValues(4, createEntry(1521658800000L, 1883657L, 353330L)); + mNetworkStatsHistory.setValues(5, createEntry(1521662400000L, 705259L, 279065L)); + mNetworkStatsHistory.setValues(5, createEntry(1521666000000L, 216169L, 155302L)); + mNetworkStatsHistory.setValues(5, createEntry(1521669600000L, 6069175L, 427581L)); + mNetworkStatsHistory.setValues(5, createEntry(1521673200000L, 120389L, 110807L)); + mNetworkStatsHistory.setValues(5, createEntry(1521676800000L, 29947L, 73257L)); + } + + /** + * Create a network entry to be used to calculate the usage chart. In the calculation, we only + * need bucketStart, total bytes (rx + tx), and bucketDuration (which is set when we create + * the NetworkStatsHistory object). Other fields are ignored, so we don't initialize here. + * @param start the timestamp when this entry begins + * @param rx the total number of received bytes + * @param tx the total number of transmitted bytes + * @return the network entry with the corresponding start time and data usage + */ + private Entry createEntry(long start, long rx, long tx) { + Entry entry = new Entry(); + entry.bucketStart = start; + entry.rxBytes = rx; + entry.txBytes = tx; + return entry; + } +} diff --git a/tests/robotests/src/com/android/settings/graph/UsageGraphTest.java b/tests/robotests/src/com/android/settings/graph/UsageGraphTest.java index e2dd99d994e..788d130d3d8 100644 --- a/tests/robotests/src/com/android/settings/graph/UsageGraphTest.java +++ b/tests/robotests/src/com/android/settings/graph/UsageGraphTest.java @@ -59,7 +59,7 @@ public class UsageGraphTest { } @Test - public void testCalculateLocalPaths_singlePath() { + public void calculateLocalPaths_singlePath() { SparseIntArray paths = new SparseIntArray(); paths.append(0, 100); paths.append(500, 50); @@ -78,7 +78,7 @@ public class UsageGraphTest { } @Test - public void testCalculateLocalPaths_multiplePaths() { + public void calculateLocalPaths_multiplePaths() { SparseIntArray paths = new SparseIntArray(); paths.append(0, 100); paths.append(200, 75); @@ -109,7 +109,7 @@ public class UsageGraphTest { } @Test - public void testCalculateLocalPaths_similarPointMiddle() { + public void calculateLocalPaths_similarPointMiddle() { SparseIntArray paths = new SparseIntArray(); paths.append(0, 100); paths.append(1, 99); // This point should be omitted. @@ -129,7 +129,7 @@ public class UsageGraphTest { } @Test - public void testCalculateLocalPaths_similarPointEnd() { + public void calculateLocalPaths_similarPointEnd() { SparseIntArray paths = new SparseIntArray(); paths.append(0, 100); paths.append(499, 51); @@ -149,4 +149,32 @@ public class UsageGraphTest { assertThat(localPaths.keyAt(3)).isEqualTo(1001); assertThat(localPaths.valueAt(3)).isEqualTo(-1); } + + @Test + public void calculateLocalPaths_unavailableData_shouldInsertFlatPoint() { + SparseIntArray paths = new SparseIntArray(); + paths.append(0, 0); + paths.append(199, -1); + paths.append(200, 25); + paths.append(300, 50); + paths.append(500, 75); + paths.append(501, -1); + + SparseIntArray localPaths = new SparseIntArray(); + mGraph.calculateLocalPaths(paths, localPaths); + + assertThat(localPaths.size()).isEqualTo(6); + assertThat(localPaths.keyAt(0)).isEqualTo(0); + assertThat(localPaths.valueAt(0)).isEqualTo(200); + assertThat(localPaths.keyAt(1)).isEqualTo(399); + assertThat(localPaths.valueAt(1)).isEqualTo(200); + assertThat(localPaths.keyAt(2)).isEqualTo(400); + assertThat(localPaths.valueAt(2)).isEqualTo(150); + assertThat(localPaths.keyAt(3)).isEqualTo(600); + assertThat(localPaths.valueAt(3)).isEqualTo(100); + assertThat(localPaths.keyAt(4)).isEqualTo(1000); + assertThat(localPaths.valueAt(4)).isEqualTo(50); + assertThat(localPaths.keyAt(5)).isEqualTo(1001); + assertThat(localPaths.valueAt(5)).isEqualTo(-1); + } }