From 155c1785e19be5b1d3054bfae6f0312e273cc482 Mon Sep 17 00:00:00 2001 From: jackqdyulei Date: Tue, 6 Mar 2018 10:28:29 -0800 Subject: [PATCH] Add auto restriction preference 1. Add method in feature provider to check whether smart battery is supported 2. Hook up above method to controllers 3. Add auto restriction preference 4. Add tests Bug: 73002171 Test: RunSettingsRoboTests Change-Id: Ic314f61ad52e9bedb629b308731cb968bb4b1773 Merged-In: Ic314f61ad52e9bedb629b308731cb968bb4b1773 (cherry picked from commit ab0b0add0a9b7409db016b0f1561612c16173fbd) --- res/values/strings.xml | 5 + res/xml/smart_battery_detail.xml | 10 +- .../AutoRestrictionPreferenceController.java | 65 ++++++++++ .../fuelgauge/PowerUsageFeatureProvider.java | 5 + .../PowerUsageFeatureProviderImpl.java | 5 + .../SmartBatteryPreferenceController.java | 11 +- ...toRestrictionPreferenceControllerTest.java | 115 ++++++++++++++++++ .../PowerUsageFeatureProviderImplTest.java | 5 + .../SmartBatteryPreferenceControllerTest.java | 26 ++++ 9 files changed, 242 insertions(+), 5 deletions(-) create mode 100644 src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java create mode 100644 tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java diff --git a/res/values/strings.xml b/res/values/strings.xml index 4e81b7a129c..011fce6889b 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -4898,6 +4898,11 @@ %1$d apps + + Restrict apps automatically + + Prevent apps from using extra battery in the background + Stop app? diff --git a/res/xml/smart_battery_detail.xml b/res/xml/smart_battery_detail.xml index a236cb824e1..e7fb9f798f1 100644 --- a/res/xml/smart_battery_detail.xml +++ b/res/xml/smart_battery_detail.xml @@ -15,7 +15,9 @@ limitations under the License. --> - @@ -32,6 +34,12 @@ android:title="@string/smart_battery_title" android:summary="@string/smart_battery_summary"/> + + diff --git a/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java b/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java new file mode 100644 index 00000000000..e8e5ad90611 --- /dev/null +++ b/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceController.java @@ -0,0 +1,65 @@ +/* + * 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.fuelgauge; + +import android.content.Context; +import android.provider.Settings; +import android.support.v14.preference.SwitchPreference; +import android.support.v7.preference.Preference; + +import com.android.settings.core.BasePreferenceController; +import com.android.settings.overlay.FeatureFactory; + +/** + * Controller to change and update the auto restriction toggle + */ +public class AutoRestrictionPreferenceController extends BasePreferenceController implements + Preference.OnPreferenceChangeListener { + private static final String KEY_SMART_BATTERY = "auto_restriction"; + private static final int ON = 1; + private static final int OFF = 0; + private PowerUsageFeatureProvider mPowerUsageFeatureProvider; + + public AutoRestrictionPreferenceController(Context context) { + super(context, KEY_SMART_BATTERY); + mPowerUsageFeatureProvider = FeatureFactory.getFactory( + context).getPowerUsageFeatureProvider(context); + } + + @Override + public int getAvailabilityStatus() { + return mPowerUsageFeatureProvider.isSmartBatterySupported() + ? DISABLED_UNSUPPORTED + : AVAILABLE; + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + final boolean smartBatteryOn = Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON) == ON; + ((SwitchPreference) preference).setChecked(smartBatteryOn); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + final boolean smartBatteryOn = (Boolean) newValue; + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.APP_AUTO_RESTRICTION_ENABLED, + smartBatteryOn ? ON : OFF); + return true; + } +} diff --git a/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java b/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java index 79675cb3bd9..861ee5622b5 100644 --- a/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java +++ b/src/com/android/settings/fuelgauge/PowerUsageFeatureProvider.java @@ -118,4 +118,9 @@ public interface PowerUsageFeatureProvider { * the caller */ boolean getEarlyWarningSignal(Context context, String id); + + /** + * Checks whether smart battery feature is supported in this device + */ + boolean isSmartBatterySupported(); } diff --git a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java index 93c4e032522..6c3897de02a 100644 --- a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java +++ b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java @@ -136,4 +136,9 @@ public class PowerUsageFeatureProviderImpl implements PowerUsageFeatureProvider public boolean getEarlyWarningSignal(Context context, String id) { return false; } + + @Override + public boolean isSmartBatterySupported() { + return false; + } } diff --git a/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java b/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java index ee5279e027f..8b99a4361a7 100644 --- a/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java +++ b/src/com/android/settings/fuelgauge/SmartBatteryPreferenceController.java @@ -19,12 +19,11 @@ package com.android.settings.fuelgauge; import android.content.Context; import android.provider.Settings; -import android.support.annotation.VisibleForTesting; import android.support.v14.preference.SwitchPreference; import android.support.v7.preference.Preference; -import com.android.settings.applications.LayoutPreference; import com.android.settings.core.BasePreferenceController; +import com.android.settings.overlay.FeatureFactory; /** * Controller to change and update the smart battery toggle @@ -34,15 +33,19 @@ public class SmartBatteryPreferenceController extends BasePreferenceController i private static final String KEY_SMART_BATTERY = "smart_battery"; private static final int ON = 1; private static final int OFF = 0; + private PowerUsageFeatureProvider mPowerUsageFeatureProvider; public SmartBatteryPreferenceController(Context context) { super(context, KEY_SMART_BATTERY); + mPowerUsageFeatureProvider = FeatureFactory.getFactory(context) + .getPowerUsageFeatureProvider(context); } @Override public int getAvailabilityStatus() { - // TODO(b/71502850): get Availability from API. The device may not support it. - return AVAILABLE; + return mPowerUsageFeatureProvider.isSmartBatterySupported() + ? AVAILABLE + : DISABLED_UNSUPPORTED; } @Override diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java new file mode 100644 index 00000000000..241f5502031 --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/AutoRestrictionPreferenceControllerTest.java @@ -0,0 +1,115 @@ +/* + * 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.fuelgauge; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; + +import android.content.Context; +import android.provider.Settings; +import android.support.v14.preference.SwitchPreference; + +import com.android.settings.core.BasePreferenceController; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class AutoRestrictionPreferenceControllerTest { + private static final int ON = 1; + private static final int OFF = 0; + + private AutoRestrictionPreferenceController mController; + private SwitchPreference mPreference; + private Context mContext; + private FakeFeatureFactory mFeatureFactory; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mFeatureFactory = FakeFeatureFactory.setupForTest(); + mContext = RuntimeEnvironment.application; + mController = new AutoRestrictionPreferenceController(mContext); + mPreference = new SwitchPreference(mContext); + } + + @Test + public void testUpdateState_AutoRestrictionOn_preferenceChecked() { + putAutoRestrictionValue(ON); + + mController.updateState(mPreference); + + assertThat(mPreference.isChecked()).isTrue(); + } + + @Test + public void testUpdateState_AutoRestrictionOff_preferenceUnchecked() { + putAutoRestrictionValue(OFF); + + mController.updateState(mPreference); + + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void testUpdateState_checkPreference_autoRestrictionOn() { + mController.onPreferenceChange(mPreference, true); + + assertThat(getAutoRestrictionValue()).isEqualTo(ON); + } + + @Test + public void testUpdateState_unCheckPreference_autoRestrictionOff() { + mController.onPreferenceChange(mPreference, false); + + assertThat(getAutoRestrictionValue()).isEqualTo(OFF); + } + + @Test + public void testGetAvailabilityStatus_smartBatterySupported_returnDisabled() { + doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.DISABLED_UNSUPPORTED); + } + + @Test + public void testGetAvailabilityStatus_smartBatteryUnSupported_returnAvailable() { + doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.AVAILABLE); + } + + private void putAutoRestrictionValue(int value) { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.APP_AUTO_RESTRICTION_ENABLED, + value); + } + + private int getAutoRestrictionValue() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.APP_AUTO_RESTRICTION_ENABLED, ON); + } +} diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java index f37d607530c..70acb73b05f 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java @@ -136,4 +136,9 @@ public class PowerUsageFeatureProviderImplTest { public void testIsPowerAccountingToggleEnabled_returnTrue() { assertThat(mPowerFeatureProvider.isPowerAccountingToggleEnabled()).isTrue(); } + + @Test + public void testIsSmartBatterySupported_returnFalse() { + assertThat(mPowerFeatureProvider.isSmartBatterySupported()).isFalse(); + } } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java index 494d563b4d2..fbbc6f9e612 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java @@ -18,10 +18,16 @@ package com.android.settings.fuelgauge; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; + import android.content.ContentResolver; +import android.content.Context; import android.provider.Settings; import android.support.v14.preference.SwitchPreference; +import com.android.settings.core.BasePreferenceController; +import com.android.settings.testutils.FakeFeatureFactory; + import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -38,11 +44,15 @@ public class SmartBatteryPreferenceControllerTest { private SmartBatteryPreferenceController mController; private SwitchPreference mPreference; private ContentResolver mContentResolver; + private Context mContext; + private FakeFeatureFactory mFeatureFactory; + @Before public void setUp() { MockitoAnnotations.initMocks(this); + mFeatureFactory = FakeFeatureFactory.setupForTest(); mContentResolver = RuntimeEnvironment.application.getContentResolver(); mController = new SmartBatteryPreferenceController(RuntimeEnvironment.application); mPreference = new SwitchPreference(RuntimeEnvironment.application); @@ -80,6 +90,22 @@ public class SmartBatteryPreferenceControllerTest { assertThat(getSmartBatteryValue()).isEqualTo(OFF); } + @Test + public void testGetAvailabilityStatus_smartBatterySupported_returnAvailable() { + doReturn(true).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.AVAILABLE); + } + + @Test + public void testGetAvailabilityStatus_smartBatteryUnSupported_returnDisabled() { + doReturn(false).when(mFeatureFactory.powerUsageFeatureProvider).isSmartBatterySupported(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.DISABLED_UNSUPPORTED); + } + private void putSmartBatteryValue(int value) { Settings.Global.putInt(mContentResolver, Settings.Global.APP_STANDBY_ENABLED, value); }