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

res/values/strings.xml

@@ -4898,6 +4898,11 @@
         <item quantity="other">%1$d apps</item>
     </plurals>
 
+    <!-- Title for auto restriction toggle -->
+    <string name="battery_auto_restriction_title">Restrict apps automatically</string>
+    <!-- Summary for auto restriction toggle -->
+    <string name="battery_auto_restriction_summary">Prevent apps from using extra battery in the background</string>
+
     <!-- Title for force stop dialog [CHAR LIMIT=30] -->
     <string name="dialog_stop_title">Stop app?</string>
     <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->

res/xml/smart_battery_detail.xml

@@ -15,7 +15,9 @@
   limitations under the License.
   -->
 
-<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+<PreferenceScreen
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:settings="http://schemas.android.com/apk/res-auto"
     android:key="smart_battery_detail"
     android:title="@string/smart_battery_manager_title">
 
@@ -32,6 +34,12 @@
         android:title="@string/smart_battery_title"
         android:summary="@string/smart_battery_summary"/>
 
+    <SwitchPreference
+        android:key="auto_restriction"
+        android:title="@string/battery_auto_restriction_title"
+        android:summary="@string/battery_auto_restriction_summary"
+        settings:controller="com.android.settings.fuelgauge.AutoRestrictionPreferenceController"/>
+
     <Preference
         android:key="restricted_app"
         android:title="@string/restricted_app_title"/>

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

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

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

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

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

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

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