From 03a5612355617803d8c355b3eef70379fb6f05da Mon Sep 17 00:00:00 2001 From: jackqdyulei Date: Wed, 13 Dec 2017 13:40:24 -0800 Subject: [PATCH] Add BatteryTipPolicy BatteryTipPolicy contains all experimental values we could tune for battery tip. Bug: 70570352 Test: RunSettingsRoboTests Change-Id: I26a3c2260dc6ff5cb10e3a4c1d55a715cc5c9a9d --- .../batterytip/BatteryTipPolicy.java | 153 ++++++++++++++++++ .../batterytip/BatteryTipPolicyTest.java | 95 +++++++++++ 2 files changed, 248 insertions(+) create mode 100644 src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicy.java create mode 100644 tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicyTest.java diff --git a/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicy.java b/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicy.java new file mode 100644 index 00000000000..ac5072d2b2c --- /dev/null +++ b/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicy.java @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2017 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.fuelgauge.batterytip; + +import android.content.Context; +import android.provider.Settings; +import android.support.annotation.VisibleForTesting; +import android.util.KeyValueListParser; +import android.util.Log; + +/** + * Class to store the policy for battery tips, which comes from + * {@link Settings.Global} + */ +public class BatteryTipPolicy { + public static final String TAG = "BatteryTipPolicy"; + + private static final String KEY_BATTERY_TIP_ENABLED = "battery_tip_enabled"; + private static final String KEY_SUMMARY_ENABLED = "summary_enabled"; + private static final String KEY_BATTERY_SAVER_TIP_ENABLED = "battery_saver_tip_enabled"; + private static final String KEY_HIGH_USAGE_ENABLED = "high_usage_enabled"; + private static final String KEY_HIGH_USAGE_APP_COUNT = "high_usage_app_count"; + private static final String KEY_APP_RESTRICTION_ENABLED = "app_restriction_enabled"; + private static final String KEY_REDUCED_BATTERY_ENABLED = "reduced_battery_enabled"; + private static final String KEY_REDUCED_BATTERY_PERCENT = "reduced_battery_percent"; + private static final String KEY_LOW_BATTERY_ENABLED = "low_battery_enabled"; + private static final String KEY_LOW_BATTERY_HOUR = "low_battery_hour"; + + /** + * {@code true} if general battery tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_BATTERY_TIP_ENABLED + */ + public final boolean batteryTipEnabled; + + /** + * {@code true} if summary tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_SUMMARY_ENABLED + */ + public final boolean summaryEnabled; + + /** + * {@code true} if battery saver tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_BATTERY_SAVER_TIP_ENABLED + */ + public final boolean batterySaverTipEnabled; + + /** + * {@code true} if high usage tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_HIGH_USAGE_ENABLED + */ + public final boolean highUsageEnabled; + + /** + * The maximum number of apps shown in high usage + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_HIGH_USAGE_APP_COUNT + */ + public final int highUsageAppCount; + + /** + * {@code true} if app restriction tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_APP_RESTRICTION_ENABLED + */ + public final boolean appRestrictionEnabled; + + /** + * {@code true} if reduced battery tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_REDUCED_BATTERY_ENABLED + */ + public final boolean reducedBatteryEnabled; + + /** + * The percentage of reduced battery to trigger the tip(e.g. 50%) + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_REDUCED_BATTERY_PERCENT + */ + public final int reducedBatteryPercent; + + /** + * {@code true} if low battery tip is enabled + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_LOW_BATTERY_ENABLED + */ + public final boolean lowBatteryEnabled; + + /** + * Remaining battery hour to trigger the tip(e.g. 16 hours) + * + * @see Settings.Global#BATTERY_TIP_CONSTANTS + * @see #KEY_LOW_BATTERY_HOUR + */ + public final int lowBatteryHour; + + private final KeyValueListParser mParser; + + public BatteryTipPolicy(Context context) { + this(context, new KeyValueListParser(',')); + } + + @VisibleForTesting + BatteryTipPolicy(Context context, KeyValueListParser parser) { + mParser = parser; + final String value = Settings.Global.getString(context.getContentResolver(), + Settings.Global.BATTERY_TIP_CONSTANTS); + + try { + mParser.setString(value); + } catch (IllegalArgumentException e) { + Log.e(TAG, "Bad battery tip constants"); + } + + batteryTipEnabled = mParser.getBoolean(KEY_BATTERY_TIP_ENABLED, true); + summaryEnabled = mParser.getBoolean(KEY_SUMMARY_ENABLED, true); + batterySaverTipEnabled = mParser.getBoolean(KEY_BATTERY_SAVER_TIP_ENABLED, true); + highUsageEnabled = mParser.getBoolean(KEY_HIGH_USAGE_ENABLED, true); + highUsageAppCount = mParser.getInt(KEY_HIGH_USAGE_APP_COUNT, 3); + appRestrictionEnabled = mParser.getBoolean(KEY_APP_RESTRICTION_ENABLED, true); + reducedBatteryEnabled = mParser.getBoolean(KEY_REDUCED_BATTERY_ENABLED, true); + reducedBatteryPercent = mParser.getInt(KEY_REDUCED_BATTERY_PERCENT, 50); + lowBatteryEnabled = mParser.getBoolean(KEY_LOW_BATTERY_ENABLED, true); + lowBatteryHour = mParser.getInt(KEY_LOW_BATTERY_HOUR, 16); + } + +} diff --git a/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicyTest.java b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicyTest.java new file mode 100644 index 00000000000..1198b270cf2 --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/batterytip/BatteryTipPolicyTest.java @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2017 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.fuelgauge.batterytip; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.provider.Settings; + +import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Config; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class BatteryTipPolicyTest { + private static final String BATTERY_TIP_CONSTANTS_VALUE = "battery_tip_enabled=true" + + ",summary_enabled=false" + + ",battery_saver_tip_enabled=false" + + ",high_usage_enabled=true" + + ",high_usage_app_count=5" + + ",app_restriction_enabled=true" + + ",reduced_battery_enabled=true" + + ",reduced_battery_percent=30" + + ",low_battery_enabled=false" + + ",low_battery_hour=10"; + private Context mContext; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + } + + @Test + public void testInit_usesConfigValues() { + Settings.Global.putString(mContext.getContentResolver(), + Settings.Global.BATTERY_TIP_CONSTANTS, BATTERY_TIP_CONSTANTS_VALUE); + + final BatteryTipPolicy batteryTipPolicy = new BatteryTipPolicy(mContext); + + assertThat(batteryTipPolicy.batteryTipEnabled).isTrue(); + assertThat(batteryTipPolicy.summaryEnabled).isFalse(); + assertThat(batteryTipPolicy.batterySaverTipEnabled).isFalse(); + assertThat(batteryTipPolicy.highUsageEnabled).isTrue(); + assertThat(batteryTipPolicy.highUsageAppCount).isEqualTo(5); + assertThat(batteryTipPolicy.appRestrictionEnabled).isTrue(); + assertThat(batteryTipPolicy.reducedBatteryEnabled).isTrue(); + assertThat(batteryTipPolicy.reducedBatteryPercent).isEqualTo(30); + assertThat(batteryTipPolicy.lowBatteryEnabled).isFalse(); + assertThat(batteryTipPolicy.lowBatteryHour).isEqualTo(10); + } + + @Test + public void testInit_defaultValues() { + Settings.Global.putString(mContext.getContentResolver(), + Settings.Global.BATTERY_TIP_CONSTANTS, ""); + + final BatteryTipPolicy batteryTipPolicy = new BatteryTipPolicy(mContext); + + assertThat(batteryTipPolicy.batteryTipEnabled).isTrue(); + assertThat(batteryTipPolicy.summaryEnabled).isTrue(); + assertThat(batteryTipPolicy.batterySaverTipEnabled).isTrue(); + assertThat(batteryTipPolicy.highUsageEnabled).isTrue(); + assertThat(batteryTipPolicy.highUsageAppCount).isEqualTo(3); + assertThat(batteryTipPolicy.appRestrictionEnabled).isTrue(); + assertThat(batteryTipPolicy.reducedBatteryEnabled).isTrue(); + assertThat(batteryTipPolicy.reducedBatteryPercent).isEqualTo(50); + assertThat(batteryTipPolicy.lowBatteryEnabled).isTrue(); + assertThat(batteryTipPolicy.lowBatteryHour).isEqualTo(16); + } + +}