From 236a376211dd1d314c13db5aded1d6f716c00188 Mon Sep 17 00:00:00 2001 From: menghanli Date: Fri, 15 Jul 2022 12:31:38 +0800 Subject: [PATCH] Refactor AccessibilityControlTimeoutPreferenceFragment to improve maintainability MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Root cause: There is a bunch of different logic of preferences in AccessibilityControlTimeoutPreferenceFragment. It’s hard to implement new features and hard to maintain and hard to be testable. Solution: Move out logic of AccessibilityControlTimeoutPreferenceFragment into controllers to reduce the complexity of the relationship between preference and fragment. Bug: 197695932 Test: make RunSettingsRoboTests ROBOTEST_FILTER=com.android.settings.accessibility Change-Id: I22e6e3b9e2f199ac1721fc069690321ad5f7a0d4 --- ...accessibility_control_timeout_settings.xml | 17 +- ...ilityControlTimeoutPreferenceFragment.java | 70 +------ .../AccessibilityTimeoutController.java | 188 +++++++----------- ...essibilityTimeoutPreferenceController.java | 19 +- .../AccessibilityTimeoutUtils.java | 44 ++++ ...yControlTimeoutPreferenceFragmentTest.java | 82 ++++++++ .../AccessibilityTimeoutControllerTest.java | 62 +++--- ...bilityTimeoutPreferenceControllerTest.java | 19 +- .../AccessibilityTimeoutUtilsTest.java | 65 ++++++ 9 files changed, 334 insertions(+), 232 deletions(-) create mode 100644 src/com/android/settings/accessibility/AccessibilityTimeoutUtils.java create mode 100644 tests/robotests/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragmentTest.java create mode 100644 tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutUtilsTest.java diff --git a/res/xml/accessibility_control_timeout_settings.xml b/res/xml/accessibility_control_timeout_settings.xml index 3cd0dd63e63..5a1bd17121d 100644 --- a/res/xml/accessibility_control_timeout_settings.xml +++ b/res/xml/accessibility_control_timeout_settings.xml @@ -18,13 +18,11 @@ + android:title="@string/accessibility_control_timeout_preference_title"> + android:title="@string/accessibility_control_timeout_preference_intro_text"/> + settings:controller="com.android.settings.accessibility.AccessibilityTimeoutController"/> + settings:controller="com.android.settings.accessibility.AccessibilityTimeoutController"/> + settings:controller="com.android.settings.accessibility.AccessibilityTimeoutController"/> + settings:controller="com.android.settings.accessibility.AccessibilityTimeoutController"/> + settings:controller="com.android.settings.accessibility.AccessibilityTimeoutController"/> diff --git a/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragment.java b/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragment.java index c7a9b10aab9..d7e33ae28a0 100644 --- a/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragment.java +++ b/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragment.java @@ -17,55 +17,17 @@ package com.android.settings.accessibility; import android.app.settings.SettingsEnums; -import android.content.Context; -import android.content.res.Resources; - -import androidx.preference.Preference; import com.android.settings.R; import com.android.settings.dashboard.DashboardFragment; import com.android.settings.search.BaseSearchIndexProvider; -import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.Lifecycle; import com.android.settingslib.search.SearchIndexable; -import java.util.ArrayList; -import java.util.List; - /** Settings fragment containing accessibility control timeout preference. */ @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC) -public final class AccessibilityControlTimeoutPreferenceFragment extends DashboardFragment - implements AccessibilityTimeoutController.OnChangeListener { +public final class AccessibilityControlTimeoutPreferenceFragment extends DashboardFragment { static final String TAG = "AccessibilityControlTimeoutPreferenceFragment"; - private static final List sControllers = new ArrayList<>(); - - @Override - public void onCheckedChanged(Preference preference) { - for (AbstractPreferenceController controller : sControllers) { - controller.updateState(preference); - } - } - - @Override - public void onResume() { - super.onResume(); - - for (AbstractPreferenceController controller : - buildPreferenceControllers(getPrefContext(), getSettingsLifecycle())) { - ((AccessibilityTimeoutController)controller).setOnChangeListener(this); - } - } - - @Override - public void onPause() { - super.onPause(); - - for (AbstractPreferenceController controller : - buildPreferenceControllers(getPrefContext(), getSettingsLifecycle())) { - ((AccessibilityTimeoutController)controller).setOnChangeListener(null); - } - } @Override public int getMetricsCategory() { @@ -82,39 +44,11 @@ public final class AccessibilityControlTimeoutPreferenceFragment extends Dashboa return R.xml.accessibility_control_timeout_settings; } - @Override - protected List createPreferenceControllers(Context context) { - return buildPreferenceControllers(context, getSettingsLifecycle()); - } - @Override public int getHelpResource() { return R.string.help_url_timeout; } - private static List buildPreferenceControllers(Context context, - Lifecycle lifecycle) { - if (sControllers.size() == 0) { - Resources resources = context.getResources(); - - String[] timeoutKeys = resources.getStringArray( - R.array.accessibility_timeout_control_selector_keys); - - for (int i=0; i < timeoutKeys.length; i++) { - sControllers.add(new AccessibilityTimeoutController( - context, lifecycle, timeoutKeys[i])); - } - } - return sControllers; - } - public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = - new BaseSearchIndexProvider(R.xml.accessibility_control_timeout_settings) { - - @Override - public List createPreferenceControllers( - Context context) { - return buildPreferenceControllers(context, null); - } - }; + new BaseSearchIndexProvider(R.xml.accessibility_control_timeout_settings); } diff --git a/src/com/android/settings/accessibility/AccessibilityTimeoutController.java b/src/com/android/settings/accessibility/AccessibilityTimeoutController.java index 2d624c33641..b306cd88e53 100644 --- a/src/com/android/settings/accessibility/AccessibilityTimeoutController.java +++ b/src/com/android/settings/accessibility/AccessibilityTimeoutController.java @@ -19,79 +19,114 @@ package com.android.settings.accessibility; import android.content.ContentResolver; import android.content.Context; import android.content.res.Resources; +import android.os.Handler; +import android.os.Looper; import android.provider.Settings; -import androidx.lifecycle.LifecycleObserver; +import androidx.annotation.VisibleForTesting; import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import com.android.settings.R; -import com.android.settings.core.PreferenceControllerMixin; -import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settings.core.BasePreferenceController; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; import com.android.settingslib.widget.SelectorWithWidgetPreference; -import com.google.common.primitives.Ints; - +import java.util.Arrays; import java.util.HashMap; +import java.util.List; import java.util.Map; -/** - * Controller class that control accessibility time out settings. - */ -public class AccessibilityTimeoutController extends AbstractPreferenceController implements - LifecycleObserver, SelectorWithWidgetPreference.OnClickListener, PreferenceControllerMixin { - static final String CONTENT_TIMEOUT_SETTINGS_SECURE = - Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS; - static final String CONTROL_TIMEOUT_SETTINGS_SECURE = - Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS; +/** Controller class that control accessibility timeout settings. */ +public class AccessibilityTimeoutController extends BasePreferenceController implements + LifecycleObserver, OnStart, OnStop , SelectorWithWidgetPreference.OnClickListener { + + private static final List ACCESSIBILITY_TIMEOUT_FEATURE_KEYS = Arrays.asList( + Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS, + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS + ); // pair the preference key and timeout value. private final Map mAccessibilityTimeoutKeyToValueMap = new HashMap<>(); - // RadioButtonPreference key, each preference represent a timeout value. - private final String mPreferenceKey; private final ContentResolver mContentResolver; private final Resources mResources; - private OnChangeListener mOnChangeListener; private SelectorWithWidgetPreference mPreference; private int mAccessibilityUiTimeoutValue; + private AccessibilitySettingsContentObserver mSettingsContentObserver; - public AccessibilityTimeoutController(Context context, Lifecycle lifecycle, - String preferenceKey) { - super(context); - + public AccessibilityTimeoutController(Context context, String preferenceKey) { + super(context, preferenceKey); mContentResolver = context.getContentResolver(); mResources = context.getResources(); - - if (lifecycle != null) { - lifecycle.addObserver(this); - } - mPreferenceKey = preferenceKey; + mSettingsContentObserver = new AccessibilitySettingsContentObserver( + new Handler(Looper.getMainLooper())); + mSettingsContentObserver.registerKeysToObserverCallback(ACCESSIBILITY_TIMEOUT_FEATURE_KEYS, + key -> updateState(mPreference)); } - protected static int getSecureAccessibilityTimeoutValue(ContentResolver resolver, String name) { - String timeOutSec = Settings.Secure.getString(resolver, name); - if (timeOutSec == null) { - return 0; - } - Integer timeOutValue = Ints.tryParse(timeOutSec); - return timeOutValue == null ? 0 : timeOutValue; + @VisibleForTesting + AccessibilityTimeoutController(Context context, String preferenceKey, + AccessibilitySettingsContentObserver contentObserver) { + this(context, preferenceKey); + mSettingsContentObserver = contentObserver; } - public void setOnChangeListener(OnChangeListener listener) { - mOnChangeListener = listener; + @Override + public void onStart() { + mSettingsContentObserver.register(mContentResolver); + } + + @Override + public void onStop() { + mSettingsContentObserver.unregister(mContentResolver); + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + mPreference.setOnClickListener(this); + } + + @Override + public void onRadioButtonClicked(SelectorWithWidgetPreference preference) { + final String value = String.valueOf(getTimeoutValueToKeyMap().get(mPreferenceKey)); + + // save value to both content and control timeout setting. + Settings.Secure.putString(mContentResolver, + Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS, value); + Settings.Secure.putString(mContentResolver, + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, value); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + mAccessibilityUiTimeoutValue = AccessibilityTimeoutUtils.getSecureAccessibilityTimeoutValue( + mContentResolver); + + // reset RadioButton + mPreference.setChecked(false); + final int preferenceValue = getTimeoutValueToKeyMap().get(mPreference.getKey()); + if (mAccessibilityUiTimeoutValue == preferenceValue) { + mPreference.setChecked(true); + } } private Map getTimeoutValueToKeyMap() { if (mAccessibilityTimeoutKeyToValueMap.size() == 0) { - String[] timeoutKeys = mResources.getStringArray( R.array.accessibility_timeout_control_selector_keys); - - int[] timeoutValues = mResources.getIntArray( + final int[] timeoutValues = mResources.getIntArray( R.array.accessibility_timeout_selector_values); - final int timeoutValueCount = timeoutValues.length; for (int i = 0; i < timeoutValueCount; i++) { mAccessibilityTimeoutKeyToValueMap.put(timeoutKeys[i], timeoutValues[i]); @@ -99,77 +134,4 @@ public class AccessibilityTimeoutController extends AbstractPreferenceController } return mAccessibilityTimeoutKeyToValueMap; } - - private void putSecureString(String name, String value) { - Settings.Secure.putString(mContentResolver, name, value); - } - - private void handlePreferenceChange(String value) { - // save value to both content and control timeout setting. - putSecureString(Settings.Secure.ACCESSIBILITY_NON_INTERACTIVE_UI_TIMEOUT_MS, value); - putSecureString(Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, value); - } - - @Override - public boolean isAvailable() { - return true; - } - - @Override - public String getPreferenceKey() { - return mPreferenceKey; - } - - @Override - public void displayPreference(PreferenceScreen screen) { - super.displayPreference(screen); - - mPreference = (SelectorWithWidgetPreference) - screen.findPreference(getPreferenceKey()); - mPreference.setOnClickListener(this); - } - - @Override - public void onRadioButtonClicked(SelectorWithWidgetPreference preference) { - int value = getTimeoutValueToKeyMap().get(mPreferenceKey); - handlePreferenceChange(String.valueOf(value)); - if (mOnChangeListener != null) { - mOnChangeListener.onCheckedChanged(mPreference); - } - } - - private int getAccessibilityTimeoutValue() { - // get accessibility control timeout value - int timeoutValue = getSecureAccessibilityTimeoutValue(mContentResolver, - CONTROL_TIMEOUT_SETTINGS_SECURE); - return timeoutValue; - } - - protected void updatePreferenceCheckedState(int value) { - if (mAccessibilityUiTimeoutValue == value) { - mPreference.setChecked(true); - } - } - - @Override - public void updateState(Preference preference) { - super.updateState(preference); - - mAccessibilityUiTimeoutValue = getAccessibilityTimeoutValue(); - - // reset RadioButton - mPreference.setChecked(false); - int preferenceValue = getTimeoutValueToKeyMap().get(mPreference.getKey()); - updatePreferenceCheckedState(preferenceValue); - } - - /** - * Listener interface handles checked event. - */ - public interface OnChangeListener { - /** - * A hook that is called when preference checked. - */ - void onCheckedChanged(Preference preference); - } } diff --git a/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceController.java b/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceController.java index e7b0e3ca203..d703a92f818 100644 --- a/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceController.java +++ b/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceController.java @@ -16,17 +16,25 @@ package com.android.settings.accessibility; +import android.content.ContentResolver; import android.content.Context; +import android.content.res.Resources; import com.android.settings.R; import com.android.settings.core.BasePreferenceController; import com.google.common.primitives.Ints; +/** Preference controller for accessibility timeout. */ public class AccessibilityTimeoutPreferenceController extends BasePreferenceController { + private final ContentResolver mContentResolver; + private final Resources mResources; + public AccessibilityTimeoutPreferenceController(Context context, String preferenceKey) { super(context, preferenceKey); + mContentResolver = mContext.getContentResolver(); + mResources = mContext.getResources(); } @Override @@ -36,14 +44,13 @@ public class AccessibilityTimeoutPreferenceController extends BasePreferenceCont @Override public CharSequence getSummary() { - final String[] timeoutSummarys = mContext.getResources().getStringArray( + final String[] timeoutSummaries = mResources.getStringArray( R.array.accessibility_timeout_summaries); - final int[] timeoutValues = mContext.getResources().getIntArray( + final int[] timeoutValues = mResources.getIntArray( R.array.accessibility_timeout_selector_values); - final int timeoutValue = AccessibilityTimeoutController.getSecureAccessibilityTimeoutValue( - mContext.getContentResolver(), - AccessibilityTimeoutController.CONTROL_TIMEOUT_SETTINGS_SECURE); + final int timeoutValue = AccessibilityTimeoutUtils.getSecureAccessibilityTimeoutValue( + mContentResolver); final int idx = Ints.indexOf(timeoutValues, timeoutValue); - return timeoutSummarys[idx == -1 ? 0 : idx]; + return timeoutSummaries[idx == -1 ? 0 : idx]; } } diff --git a/src/com/android/settings/accessibility/AccessibilityTimeoutUtils.java b/src/com/android/settings/accessibility/AccessibilityTimeoutUtils.java new file mode 100644 index 00000000000..b738688267d --- /dev/null +++ b/src/com/android/settings/accessibility/AccessibilityTimeoutUtils.java @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 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.accessibility; + +import android.content.ContentResolver; +import android.provider.Settings; + +import com.google.common.primitives.Ints; + +/** Provides utility methods to accessibility timeout. */ +public final class AccessibilityTimeoutUtils { + + /** + * Gets accessibility control timeout value. + * + * @param resolver the resolver to use + * @return accessibility control timeout value + */ + public static int getSecureAccessibilityTimeoutValue(ContentResolver resolver) { + final String timeOutSec = Settings.Secure.getString(resolver, + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS); + if (timeOutSec == null) { + return 0; + } + Integer timeOutValue = Ints.tryParse(timeOutSec); + return timeOutValue == null ? 0 : timeOutValue; + } + + private AccessibilityTimeoutUtils(){} +} diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragmentTest.java new file mode 100644 index 00000000000..97407bbfe0f --- /dev/null +++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityControlTimeoutPreferenceFragmentTest.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2022 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.accessibility; + +import static com.google.common.truth.Truth.assertThat; + +import android.app.settings.SettingsEnums; +import android.content.Context; + +import androidx.test.core.app.ApplicationProvider; + +import com.android.settings.R; +import com.android.settings.testutils.XmlTestUtils; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +import java.util.List; + +/** Tests for {@link AccessibilityControlTimeoutPreferenceFragment}. */ +@RunWith(RobolectricTestRunner.class) +public class AccessibilityControlTimeoutPreferenceFragmentTest { + + private final Context mContext = ApplicationProvider.getApplicationContext(); + private AccessibilityControlTimeoutPreferenceFragment mFragment; + + @Before + public void setUp() { + mFragment = new AccessibilityControlTimeoutPreferenceFragment(); + } + + @Test + public void getMetricsCategory_returnsCorrectCategory() { + assertThat(mFragment.getMetricsCategory()).isEqualTo( + SettingsEnums.ACCESSIBILITY_TIMEOUT); + } + + @Test + public void getPreferenceScreenResId_returnsCorrectXml() { + assertThat(mFragment.getPreferenceScreenResId()).isEqualTo( + R.xml.accessibility_control_timeout_settings); + } + + @Test + public void getHelpResource_returnsCorrectHelpResource() { + assertThat(mFragment.getHelpResource()).isEqualTo(R.string.help_url_timeout); + } + + @Test + public void getLogTag_returnsCorrectTag() { + assertThat(mFragment.getLogTag()).isEqualTo( + "AccessibilityControlTimeoutPreferenceFragment"); + } + + @Test + public void getNonIndexableKeys_existInXmlLayout() { + final List niks = + AccessibilityControlTimeoutPreferenceFragment.SEARCH_INDEX_DATA_PROVIDER + .getNonIndexableKeys(mContext); + final List keys = + XmlTestUtils.getKeysFromPreferenceXml(mContext, + R.xml.accessibility_control_timeout_settings); + + assertThat(keys).containsAtLeastElementsIn(niks); + } +} diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutControllerTest.java index fc9fefb4bad..9f0b0465c7b 100644 --- a/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutControllerTest.java @@ -18,8 +18,6 @@ package com.android.settings.accessibility; import static com.google.common.truth.Truth.assertThat; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -27,59 +25,57 @@ import android.content.ContentResolver; import android.content.Context; import android.provider.Settings; -import androidx.preference.Preference; import androidx.preference.PreferenceScreen; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settings.core.BasePreferenceController; import com.android.settingslib.widget.SelectorWithWidgetPreference; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; +/** Tests for {@link AccessibilityTimeoutController}. */ @RunWith(RobolectricTestRunner.class) -public class AccessibilityTimeoutControllerTest - implements AccessibilityTimeoutController.OnChangeListener { +public class AccessibilityTimeoutControllerTest { + private static final String PREF_KEY = "accessibility_control_timeout_30secs"; - private AccessibilityTimeoutController mController; - + @Rule + public final MockitoRule mMockitoRule = MockitoJUnit.rule(); @Mock private SelectorWithWidgetPreference mMockPref; - private Context mContext; - private ContentResolver mContentResolver; - @Mock private PreferenceScreen mScreen; + @Mock + private AccessibilitySettingsContentObserver mAccessibilitySettingsContentObserver; + private Context mContext = ApplicationProvider.getApplicationContext(); + private ContentResolver mContentResolver; + private AccessibilityTimeoutController mController; @Before public void setup() { - MockitoAnnotations.initMocks(this); - mContext = RuntimeEnvironment.application; - mController = new AccessibilityTimeoutController(mContext, mock(Lifecycle.class), PREF_KEY); - mController.setOnChangeListener(this); mContentResolver = mContext.getContentResolver(); - String prefTitle = mContext.getResources().getString(R.string.accessibility_timeout_30secs); - + mController = new AccessibilityTimeoutController(mContext, PREF_KEY, + mAccessibilitySettingsContentObserver); when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mMockPref); when(mMockPref.getKey()).thenReturn(PREF_KEY); + final String prefTitle = + mContext.getResources().getString(R.string.accessibility_timeout_30secs); when(mMockPref.getTitle()).thenReturn(prefTitle); mController.displayPreference(mScreen); } - @Override - public void onCheckedChanged(Preference preference) { - mController.updateState(preference); - } - @Test - public void isAvailable() { - assertTrue(mController.isAvailable()); + public void getAvailabilityStatus_shouldReturnAvailable() { + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.AVAILABLE); } @Test @@ -115,4 +111,18 @@ public class AccessibilityTimeoutControllerTest assertThat(accessibilityUiTimeoutValue).isEqualTo("30000"); } + + @Test + public void onStart_registerSpecificContentObserverForSpecificKeys() { + mController.onStart(); + + verify(mAccessibilitySettingsContentObserver).register(mContentResolver); + } + + @Test + public void onStop_unregisterContentObserver() { + mController.onStop(); + + verify(mAccessibilitySettingsContentObserver).unregister(mContentResolver); + } } diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceControllerTest.java index 50f311e95ca..1e0dbf2576a 100644 --- a/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutPreferenceControllerTest.java @@ -21,6 +21,8 @@ import static com.google.common.truth.Truth.assertThat; import android.content.Context; import android.provider.Settings; +import androidx.test.core.app.ApplicationProvider; + import com.android.settings.R; import com.android.settings.core.BasePreferenceController; @@ -28,17 +30,16 @@ import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; +/** Tests for {@link AccessibilityTimeoutPreferenceController}. */ @RunWith(RobolectricTestRunner.class) public class AccessibilityTimeoutPreferenceControllerTest { - private Context mContext; + private Context mContext = ApplicationProvider.getApplicationContext(); private AccessibilityTimeoutPreferenceController mController; @Before public void setUp() { - mContext = RuntimeEnvironment.application; mController = new AccessibilityTimeoutPreferenceController(mContext, "control_timeout"); } @@ -50,31 +51,31 @@ public class AccessibilityTimeoutPreferenceControllerTest { @Test public void getSummary_byDefault_shouldReturnDefaultSummary() { - final String[] timeoutSummarys = mContext.getResources().getStringArray( + final String[] timeoutSummaries = mContext.getResources().getStringArray( R.array.accessibility_timeout_summaries); Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "0"); - assertThat(mController.getSummary()).isEqualTo(timeoutSummarys[0]); + assertThat(mController.getSummary().toString()).isEqualTo(timeoutSummaries[0]); } @Test public void getSummary_invalidTimeout_shouldReturnDefaultSummary() { - final String[] timeoutSummarys = mContext.getResources().getStringArray( + final String[] timeoutSummaries = mContext.getResources().getStringArray( R.array.accessibility_timeout_summaries); Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "invalid_timeout"); - assertThat(mController.getSummary()).isEqualTo(timeoutSummarys[0]); + assertThat(mController.getSummary().toString()).isEqualTo(timeoutSummaries[0]); } @Test public void getSummary_validTimeout_shouldReturnValidSummary() { - final String[] timeoutSummarys = mContext.getResources().getStringArray( + final String[] timeoutSummaries = mContext.getResources().getStringArray( R.array.accessibility_timeout_summaries); Settings.Secure.putString(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "60000"); - assertThat(mController.getSummary()).isEqualTo(timeoutSummarys[3]); + assertThat(mController.getSummary().toString()).isEqualTo(timeoutSummaries[3]); } } diff --git a/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutUtilsTest.java b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutUtilsTest.java new file mode 100644 index 00000000000..4443162d6fc --- /dev/null +++ b/tests/robotests/src/com/android/settings/accessibility/AccessibilityTimeoutUtilsTest.java @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2022 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.accessibility; + +import static com.google.common.truth.Truth.assertThat; + +import android.content.Context; +import android.provider.Settings; + +import androidx.test.core.app.ApplicationProvider; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; + +/** Tests for {@link AccessibilityTimeoutUtils}. */ +@RunWith(RobolectricTestRunner.class) +public final class AccessibilityTimeoutUtilsTest { + + private final Context mContext = ApplicationProvider.getApplicationContext(); + + @Test + public void getSecureAccessibilityTimeoutValue_byDefault_shouldReturnDefaultValue() { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "0"); + + final int timeOutValue = AccessibilityTimeoutUtils.getSecureAccessibilityTimeoutValue( + mContext.getContentResolver()); + assertThat(timeOutValue).isEqualTo(0); + } + + @Test + public void getSecureAccessibilityTimeoutValue_invalidTimeout_shouldReturnDefaultValue() { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "invalid_timeout"); + + final int timeOutValue = AccessibilityTimeoutUtils.getSecureAccessibilityTimeoutValue( + mContext.getContentResolver()); + assertThat(timeOutValue).isEqualTo(0); + } + + @Test + public void getSecureAccessibilityTimeoutValue_validTimeout_shouldReturnValidValue() { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_INTERACTIVE_UI_TIMEOUT_MS, "60000"); + + final int timeOutValue = AccessibilityTimeoutUtils.getSecureAccessibilityTimeoutValue( + mContext.getContentResolver()); + assertThat(timeOutValue).isEqualTo(60000); + } +}