From beb89c3545138b5b576dfaaa95b88a3dd375196f Mon Sep 17 00:00:00 2001 From: Dieter Hsu Date: Wed, 21 Mar 2018 18:47:43 +0800 Subject: [PATCH] Support AOD in the Universal Settings API Bug: 67997452 Test: make -j RunSettingsRoboTests Change-Id: I609ac74f70bf040bd9033f421b4bb7c02bf33440 --- res/xml/ambient_display_settings.xml | 3 +- ...ntDisplayAlwaysOnPreferenceController.java | 58 ++++------ .../display/AmbientDisplaySettings.java | 30 ++++-- ...splayAlwaysOnPreferenceControllerTest.java | 100 ++++++++---------- .../display/AmbientDisplaySettingsTest.java | 69 ++++++++++++ 5 files changed, 161 insertions(+), 99 deletions(-) create mode 100644 tests/robotests/src/com/android/settings/display/AmbientDisplaySettingsTest.java diff --git a/res/xml/ambient_display_settings.xml b/res/xml/ambient_display_settings.xml index 306ead5d50f..037421cd213 100644 --- a/res/xml/ambient_display_settings.xml +++ b/res/xml/ambient_display_settings.xml @@ -29,7 +29,8 @@ + android:summary="@string/doze_always_on_summary" + settings:controller="com.android.settings.display.AmbientDisplayAlwaysOnPreferenceController" /> buildPreferenceControllers(Context context, Lifecycle lifecycle, AmbientDisplayConfiguration config, - MetricsFeatureProvider metricsFeatureProvider, - AmbientDisplayAlwaysOnPreferenceController.OnPreferenceChangedCallback aodCallback) { + MetricsFeatureProvider metricsFeatureProvider) { final List controllers = new ArrayList<>(); controllers.add(new AmbientDisplayNotificationsPreferenceController(context, config, metricsFeatureProvider)); - controllers.add(new AmbientDisplayAlwaysOnPreferenceController(context, config, - aodCallback)); controllers.add(new DoubleTapScreenPreferenceController(context, lifecycle, config, MY_USER_ID, KEY_AMBIENT_DISPLAY_DOUBLE_TAP)); controllers.add(new PickupGesturePreferenceController(context, lifecycle, config, @@ -64,6 +64,14 @@ public class AmbientDisplaySettings extends DashboardFragment { return controllers; } + @Override + public void onAttach(Context context) { + super.onAttach(context); + final AmbientDisplayAlwaysOnPreferenceController controller = use( + AmbientDisplayAlwaysOnPreferenceController.class); + controller.setConfig(getConfig(context)); + controller.setCallback(this::updatePreferenceStates); + } @Override protected String getLogTag() { @@ -78,8 +86,7 @@ public class AmbientDisplaySettings extends DashboardFragment { @Override protected List createPreferenceControllers(Context context) { return buildPreferenceControllers(context, getLifecycle(), - new AmbientDisplayConfiguration(context), mMetricsFeatureProvider, - this::updatePreferenceStates); + getConfig(context), mMetricsFeatureProvider); } @Override @@ -104,7 +111,14 @@ public class AmbientDisplaySettings extends DashboardFragment { public List createPreferenceControllers( Context context) { return buildPreferenceControllers(context, null, - new AmbientDisplayConfiguration(context), null, null); + new AmbientDisplayConfiguration(context), null); } }; + + private AmbientDisplayConfiguration getConfig(Context context) { + if (mConfig == null) { + mConfig = new AmbientDisplayConfiguration(context); + } + return mConfig; + } } diff --git a/tests/robotests/src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceControllerTest.java index d06ea2ac50c..e1c4b70477a 100644 --- a/tests/robotests/src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/AmbientDisplayAlwaysOnPreferenceControllerTest.java @@ -17,17 +17,14 @@ package com.android.settings.display; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Matchers.anyInt; -import static org.mockito.Mockito.doReturn; + +import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.ContentResolver; import android.content.Context; import android.provider.Settings; -import android.support.v14.preference.SwitchPreference; import com.android.internal.hardware.AmbientDisplayConfiguration; import com.android.settings.search.InlinePayload; @@ -49,8 +46,6 @@ public class AmbientDisplayAlwaysOnPreferenceControllerTest { @Mock private AmbientDisplayConfiguration mConfig; - @Mock - private SwitchPreference mSwitchPreference; private Context mContext; @@ -64,95 +59,90 @@ public class AmbientDisplayAlwaysOnPreferenceControllerTest { MockitoAnnotations.initMocks(this); mContext = RuntimeEnvironment.application; mContentResolver = mContext.getContentResolver(); - mController = new AmbientDisplayAlwaysOnPreferenceController(mContext, mConfig, - () -> { - mCallbackInvoked = true; - }); + mController = new AmbientDisplayAlwaysOnPreferenceController(mContext, "key"); + mController.setConfig(mConfig); + mController.setCallback(() -> mCallbackInvoked = true); } @Test - public void updateState_enabled() { + public void getAvailabilityStatus_available() { + when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + AmbientDisplayAlwaysOnPreferenceController.AVAILABLE); + } + + @Test + public void getAvailabilityStatus_disabled_unsupported() { + when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + AmbientDisplayAlwaysOnPreferenceController.DISABLED_UNSUPPORTED); + } + + @Test + public void isChecked_enabled() { when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(true); - mController.updateState(mSwitchPreference); - - verify(mSwitchPreference).setChecked(true); + assertThat(mController.isChecked()).isTrue(); } @Test - public void updateState_disabled() { + public void isChecked_disabled() { when(mConfig.alwaysOnEnabled(anyInt())).thenReturn(false); - mController.updateState(mSwitchPreference); + assertThat(mController.isChecked()).isFalse(); + } - verify(mSwitchPreference).setChecked(false); + @Test + public void setChecked_enabled() { + mController.setChecked(true); + + assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1)) + .isEqualTo(1); + } + + @Test + public void setChecked_disabled() { + mController.setChecked(false); + + assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1)) + .isEqualTo(0); } @Test public void onPreferenceChange_callback() { assertThat(mCallbackInvoked).isFalse(); - mController.onPreferenceChange(mSwitchPreference, true); + mController.setChecked(true); assertThat(mCallbackInvoked).isTrue(); } - @Test - public void onPreferenceChange_enable() { - mController.onPreferenceChange(mSwitchPreference, true); - - assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1)) - .isEqualTo(1); - } - - @Test - public void onPreferenceChange_disable() { - mController.onPreferenceChange(mSwitchPreference, false); - - assertThat(Settings.Secure.getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, -1)) - .isEqualTo(0); - } - - @Test - public void isAvailable_available() { - mController = spy(mController); - doReturn(true).when(mController).alwaysOnAvailableForUser(any()); - - assertThat(mController.isAvailable()).isTrue(); - } - - @Test - public void isAvailable_unavailable() { - mController = spy(mController); - doReturn(false).when(mController).alwaysOnAvailableForUser(any()); - - assertThat(mController.isAvailable()).isFalse(); - } - @Test public void testPreferenceController_ProperResultPayloadType() { + when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false); mController = spy(mController); - doReturn(false).when(mController).alwaysOnAvailableForUser(any()); assertThat(mController.getResultPayload()).isInstanceOf(InlineSwitchPayload.class); } @Test public void testSetValue_updatesCorrectly() { + when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false); mController = spy(mController); - doReturn(false).when(mController).alwaysOnAvailableForUser(any()); final int newValue = 1; Settings.Secure.putInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, 0 /* value */); ((InlinePayload) mController.getResultPayload()).setValue(mContext, newValue); final int updatedValue = Settings.Secure. - getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, 1 /* default */); + getInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, 1 /* default */); assertThat(updatedValue).isEqualTo(newValue); } @Test public void testGetValue_correctValueReturned() { + when(mConfig.alwaysOnAvailableForUser(anyInt())).thenReturn(false); mController = spy(mController); - doReturn(false).when(mController).alwaysOnAvailableForUser(any()); final int currentValue = 1; Settings.Secure.putInt(mContentResolver, Settings.Secure.DOZE_ALWAYS_ON, currentValue); diff --git a/tests/robotests/src/com/android/settings/display/AmbientDisplaySettingsTest.java b/tests/robotests/src/com/android/settings/display/AmbientDisplaySettingsTest.java new file mode 100644 index 00000000000..2f6125294c5 --- /dev/null +++ b/tests/robotests/src/com/android/settings/display/AmbientDisplaySettingsTest.java @@ -0,0 +1,69 @@ +/* + * 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.display; + +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import android.content.Context; + +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settingslib.core.AbstractPreferenceController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class AmbientDisplaySettingsTest { + + private TestFragment mTestFragment; + + private Context mContext; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mTestFragment = spy(new TestFragment()); + } + + @Test + public void onAttach_shouldInvokeSetters() { + final AmbientDisplayAlwaysOnPreferenceController controller = mock( + AmbientDisplayAlwaysOnPreferenceController.class); + doReturn(controller).when(mTestFragment).use( + AmbientDisplayAlwaysOnPreferenceController.class); + + mTestFragment.onAttach(mContext); + + verify(controller).setConfig(any()); + verify(controller).setCallback(any()); + } + + public static class TestFragment extends AmbientDisplaySettings { + @Override + protected T use(Class clazz) { + return super.use(clazz); + } + } +} \ No newline at end of file