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); }