diff --git a/src/com/android/settings/datausage/DataUsageInfoController.java b/src/com/android/settings/datausage/DataUsageInfoController.java new file mode 100644 index 00000000000..115e45e50a2 --- /dev/null +++ b/src/com/android/settings/datausage/DataUsageInfoController.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2016 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 android.net.NetworkPolicy; +import com.android.settingslib.net.DataUsageController.DataUsageInfo; + +/** + * Controller to handle caching and mobile data logic. + */ +public class DataUsageInfoController { + /** + * Take the cached data usage values in the NetworkPolicy to update DataUsageInfo. + */ + public void updateDataLimit(DataUsageInfo info, NetworkPolicy policy) { + if (info == null || policy == null) { + return; + } + if (policy.warningBytes >= 0) { + info.warningLevel = policy.warningBytes; + } + if (policy.limitBytes >= 0) { + info.limitLevel = policy.limitBytes; + } + } + + /** + * @returns the most appropriate limit for the data usage summary. Use the total usage when it + * is higher than the limit and warning level. Use the limit when it is set and less than usage. + * Otherwise use warning level. + */ + public long getSummaryLimit(DataUsageInfo info) { + long limit = info.limitLevel; + if (limit <= 0) { + limit = info.warningLevel; + } + if (info.usageLevel > limit) { + limit = info.usageLevel; + } + return limit; + } +} diff --git a/src/com/android/settings/datausage/DataUsageSummary.java b/src/com/android/settings/datausage/DataUsageSummary.java index 10e6bc50c05..4fcdf303c86 100644 --- a/src/com/android/settings/datausage/DataUsageSummary.java +++ b/src/com/android/settings/datausage/DataUsageSummary.java @@ -20,7 +20,6 @@ import android.content.Context; import android.content.Intent; import android.net.ConnectivityManager; import android.net.INetworkStatsSession; -import android.net.NetworkPolicy; import android.net.NetworkTemplate; import android.net.TrafficStats; import android.os.Bundle; @@ -71,6 +70,7 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs private static final String KEY_RESTRICT_BACKGROUND = "restrict_background"; private DataUsageController mDataUsageController; + private DataUsageInfoController mDataInfoControler; private SummaryPreference mSummaryPreference; private Preference mLimitPreference; private NetworkTemplate mDefaultTemplate; @@ -82,6 +82,7 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs boolean hasMobileData = hasMobileData(getContext()); mDataUsageController = new DataUsageController(getContext()); + mDataInfoControler = new DataUsageInfoController(); addPreferencesFromResource(R.xml.data_usage); int defaultSubId = getDefaultSubscriptionId(getContext()); @@ -225,18 +226,14 @@ public class DataUsageSummary extends DataUsageBase implements Indexable, DataUs DataUsageController.DataUsageInfo info = mDataUsageController.getDataUsageInfo( mDefaultTemplate); Context context = getContext(); - NetworkPolicy policy = services.mPolicyEditor.getPolicy(mDefaultTemplate); - info.warningLevel = policy.warningBytes; + + mDataInfoControler.updateDataLimit(info, + services.mPolicyEditor.getPolicy(mDefaultTemplate)); + if (mSummaryPreference != null) { mSummaryPreference.setTitle( formatTitle(context, getString(mDataUsageTemplate), info.usageLevel)); - long limit = info.limitLevel; - if (limit <= 0) { - limit = info.warningLevel; - } - if (info.usageLevel > limit) { - limit = info.usageLevel; - } + long limit = mDataInfoControler.getSummaryLimit(info); mSummaryPreference.setSummary(info.period); mSummaryPreference.setLabels(Formatter.formatFileSize(context, 0), Formatter.formatFileSize(context, limit)); diff --git a/tests/robotests/src/com/android/settings/datausage/DataUsageInfoControllerTest.java b/tests/robotests/src/com/android/settings/datausage/DataUsageInfoControllerTest.java new file mode 100644 index 00000000000..04f241e8131 --- /dev/null +++ b/tests/robotests/src/com/android/settings/datausage/DataUsageInfoControllerTest.java @@ -0,0 +1,146 @@ +package com.android.settings.datausage; + +import android.net.NetworkPolicy; +import android.net.NetworkTemplate; +import com.android.settings.TestConfig; +import junit.framework.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.annotation.Config; + +import static com.android.settingslib.net.DataUsageController.*; +import static junit.framework.Assert.assertTrue; +import static junit.framework.Assert.fail; +import static org.junit.Assert.assertEquals; + +@RunWith(RobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class DataUsageInfoControllerTest { + private DataUsageInfoController mInfoController; + private DataUsageInfo info; + + @Before + public void setUp() { + mInfoController = new DataUsageInfoController(); + info = new DataUsageInfo(); + } + + @Test + public void testLowUsageLowWarning_LimitUsed() { + info.warningLevel = 5; + info.limitLevel = 10; + info.usageLevel = 5; + assertEquals(mInfoController.getSummaryLimit(info), info.limitLevel); + } + + @Test + public void testLowUsageEqualWarning_LimitUsed() { + info.warningLevel = 10; + info.limitLevel = 10; + info.usageLevel = 5; + assertEquals(mInfoController.getSummaryLimit(info), info.limitLevel); + } + + @Test + public void testNoLimitNoUsage_WarningUsed() { + info.warningLevel = 10; + info.limitLevel = 0; + info.usageLevel = 0; + assertEquals(mInfoController.getSummaryLimit(info), info.warningLevel); + } + + @Test + public void testNoLimitLowUsage_WarningUsed() { + info.warningLevel = 10; + info.limitLevel = 0; + info.usageLevel = 5; + assertEquals(mInfoController.getSummaryLimit(info), info.warningLevel); + } + + @Test + public void testLowWarningNoLimit_UsageUsed() { + info.warningLevel = 5; + info.limitLevel = 0; + info.usageLevel = 10; + assertEquals(mInfoController.getSummaryLimit(info), info.usageLevel); + } + + @Test + public void testLowWarningLowLimit_UsageUsed() { + info.warningLevel = 5; + info.limitLevel = 5; + info.usageLevel = 10; + assertEquals(mInfoController.getSummaryLimit(info), info.usageLevel); + } + + private NetworkPolicy getDefaultNetworkPolicy() { + NetworkTemplate template = new NetworkTemplate(NetworkTemplate.MATCH_WIFI_WILDCARD, + null, null); + int cycleDay = -1; + String cycleTimezone = "UTC"; + long warningBytes = -1; + long limitBytes = -1; + return new NetworkPolicy(template,cycleDay, cycleTimezone, warningBytes, limitBytes, true); + } + + @Test + public void testNullArguments_NoError() { + try { + mInfoController.updateDataLimit(null, null); + mInfoController.updateDataLimit(info, null); + mInfoController.updateDataLimit(null, getDefaultNetworkPolicy()); + } catch (Exception e) { + fail("Update Data Limit should drop calls with null arguments"); + } + } + + @Test + public void testNegativeWarning_UpdatedToZero() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.warningBytes = -5; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(0, info.warningLevel); + } + + @Test + public void testWarningZero_UpdatedToZero() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.warningBytes = 0; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(0, info.warningLevel); + } + + @Test + public void testWarningPositive_UpdatedToWarning() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.warningBytes = 5; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(policy.warningBytes, info.warningLevel); + } + + @Test + public void testLimitNegative_UpdatedToZero() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.limitBytes = -5; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(0, info.limitLevel); + } + + @Test + public void testLimitZero_UpdatedToZero() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.limitBytes = 0; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(0, info.limitLevel); + } + + @Test + public void testLimitPositive_UpdatedToLimit() { + NetworkPolicy policy = getDefaultNetworkPolicy(); + policy.limitBytes = 5; + mInfoController.updateDataLimit(info, policy); + Assert.assertEquals(policy.limitBytes, info.limitLevel); + } +}