diff --git a/res/xml/accessibility_daltonizer_settings.xml b/res/xml/accessibility_daltonizer_settings.xml index 1f770306890..8dc5f3b5ab4 100644 --- a/res/xml/accessibility_daltonizer_settings.xml +++ b/res/xml/accessibility_daltonizer_settings.xml @@ -32,24 +32,28 @@ android:key="daltonizer_mode_deuteranomaly" android:persistent="false" android:summary="@string/daltonizer_mode_deuteranomaly_summary" - android:title="@string/daltonizer_mode_deuteranomaly_title" /> + android:title="@string/daltonizer_mode_deuteranomaly_title" + settings:controller="com.android.settings.accessibility.DaltonizerRadioButtonPreferenceController" /> + android:title="@string/daltonizer_mode_protanomaly_title" + settings:controller="com.android.settings.accessibility.DaltonizerRadioButtonPreferenceController" /> + android:title="@string/daltonizer_mode_tritanomaly_title" + settings:controller="com.android.settings.accessibility.DaltonizerRadioButtonPreferenceController" /> + android:title="@string/daltonizer_mode_grayscale_title" + settings:controller="com.android.settings.accessibility.DaltonizerRadioButtonPreferenceController" /> mAccessibilityDaltonizerKeyToValueMap = new HashMap<>(); // RadioButtonPreference key, each preference represent a daltonizer value. private final ContentResolver mContentResolver; + private final ContentObserver mSettingsContentObserver; private final Resources mResources; - private DaltonizerRadioButtonPreferenceController.OnChangeListener mOnChangeListener; private SelectorWithWidgetPreference mPreference; - private int mAccessibilityDaltonizerValue; public DaltonizerRadioButtonPreferenceController(Context context, String preferenceKey) { super(context, preferenceKey); - mContentResolver = context.getContentResolver(); mResources = context.getResources(); + mSettingsContentObserver = new ContentObserver(new Handler(Looper.getMainLooper())) { + @Override + public void onChange(boolean selfChange) { + if (mPreference != null) { + updateState(mPreference); + } + } + }; } - public DaltonizerRadioButtonPreferenceController(Context context, Lifecycle lifecycle, - String preferenceKey) { - super(context, preferenceKey); - - mContentResolver = context.getContentResolver(); - mResources = context.getResources(); - - if (lifecycle != null) { - lifecycle.addObserver(this); - } - } - - protected static int getSecureAccessibilityDaltonizerValue(ContentResolver resolver, - String name) { - final String daltonizerStringValue = Settings.Secure.getString(resolver, name); + protected static int getSecureAccessibilityDaltonizerValue(ContentResolver resolver) { + final String daltonizerStringValue = Settings.Secure.getString( + resolver, DALTONIZER_TYPE_SETTINGS_KEY); if (daltonizerStringValue == null) { return AccessibilityManager.DALTONIZER_CORRECT_DEUTERANOMALY; } @@ -82,13 +81,8 @@ public class DaltonizerRadioButtonPreferenceController extends BasePreferenceCon : daltonizerIntValue; } - public void setOnChangeListener( - DaltonizerRadioButtonPreferenceController.OnChangeListener listener) { - mOnChangeListener = listener; - } - private Map getDaltonizerValueToKeyMap() { - if (mAccessibilityDaltonizerKeyToValueMap.size() == 0) { + if (mAccessibilityDaltonizerKeyToValueMap.isEmpty()) { final String[] daltonizerKeys = mResources.getStringArray( R.array.daltonizer_mode_keys); @@ -104,12 +98,8 @@ public class DaltonizerRadioButtonPreferenceController extends BasePreferenceCon return mAccessibilityDaltonizerKeyToValueMap; } - private void putSecureString(String name, String value) { - Settings.Secure.putString(mContentResolver, name, value); - } - private void handlePreferenceChange(String value) { - putSecureString(TYPE, value); + Settings.Secure.putString(mContentResolver, DALTONIZER_TYPE_SETTINGS_KEY, value); } @Override @@ -124,44 +114,38 @@ public class DaltonizerRadioButtonPreferenceController extends BasePreferenceCon screen.findPreference(getPreferenceKey()); mPreference.setOnClickListener(this); mPreference.setAppendixVisibility(View.GONE); - updateState(mPreference); } @Override public void onRadioButtonClicked(SelectorWithWidgetPreference preference) { final int value = getDaltonizerValueToKeyMap().get(mPreferenceKey); handlePreferenceChange(String.valueOf(value)); - if (mOnChangeListener != null) { - mOnChangeListener.onCheckedChanged(mPreference); - } } private int getAccessibilityDaltonizerValue() { - final int daltonizerValue = getSecureAccessibilityDaltonizerValue(mContentResolver, - TYPE); + final int daltonizerValue = getSecureAccessibilityDaltonizerValue(mContentResolver); return daltonizerValue; } - protected void updatePreferenceCheckedState(int value) { - if (mAccessibilityDaltonizerValue == value) { - mPreference.setChecked(true); - } - } - @Override public void updateState(Preference preference) { super.updateState(preference); - mAccessibilityDaltonizerValue = getAccessibilityDaltonizerValue(); - - // reset RadioButton - mPreference.setChecked(false); + final int daltonizerValueInSetting = getAccessibilityDaltonizerValue(); final int preferenceValue = getDaltonizerValueToKeyMap().get(mPreference.getKey()); - updatePreferenceCheckedState(preferenceValue); + mPreference.setChecked(preferenceValue == daltonizerValueInSetting); } - /** Listener interface handles checked event. */ - public interface OnChangeListener { - /** A hook that is called when preference checked. */ - void onCheckedChanged(Preference preference); + @Override + public void onResume(@NonNull LifecycleOwner owner) { + mContentResolver.registerContentObserver( + Settings.Secure.getUriFor(DALTONIZER_TYPE_SETTINGS_KEY), + /* notifyForDescendants= */ false, + mSettingsContentObserver + ); + } + + @Override + public void onPause(@NonNull LifecycleOwner owner) { + mContentResolver.unregisterContentObserver(mSettingsContentObserver); } } diff --git a/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragment.java b/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragment.java index 0cfa756778e..52f1695cbe5 100644 --- a/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragment.java +++ b/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragment.java @@ -24,8 +24,6 @@ import static com.android.settings.accessibility.AccessibilityUtil.State.ON; import android.app.settings.SettingsEnums; import android.content.ComponentName; -import android.content.Context; -import android.content.res.Resources; import android.os.Bundle; import android.provider.Settings; import android.view.LayoutInflater; @@ -33,14 +31,11 @@ import android.view.View; import android.view.ViewGroup; import androidx.annotation.VisibleForTesting; -import androidx.preference.Preference; import com.android.settings.R; import com.android.settings.accessibility.AccessibilityUtil.QuickSettingsTooltipType; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settings.widget.SettingsMainSwitchPreference; -import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.Lifecycle; import com.android.settingslib.search.SearchIndexable; import java.util.ArrayList; @@ -48,40 +43,18 @@ import java.util.List; /** Settings for daltonizer. */ @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC) -public class ToggleDaltonizerPreferenceFragment extends ToggleFeaturePreferenceFragment - implements DaltonizerRadioButtonPreferenceController.OnChangeListener { +public class ToggleDaltonizerPreferenceFragment extends ToggleFeaturePreferenceFragment { private static final String TAG = "ToggleDaltonizerPreferenceFragment"; private static final String ENABLED = Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED; private static final String KEY_PREVIEW = "daltonizer_preview"; - @VisibleForTesting - static final String KEY_DEUTERANOMALY = "daltonizer_mode_deuteranomaly"; - @VisibleForTesting - static final String KEY_PROTANOMALY = "daltonizer_mode_protanomaly"; - @VisibleForTesting - static final String KEY_TRITANOMEALY = "daltonizer_mode_tritanomaly"; - @VisibleForTesting - static final String KEY_GRAYSCALE = "daltonizer_mode_grayscale"; + private static final String KEY_DEUTERANOMALY = "daltonizer_mode_deuteranomaly"; + private static final String KEY_PROTANOMALY = "daltonizer_mode_protanomaly"; + private static final String KEY_TRITANOMEALY = "daltonizer_mode_tritanomaly"; + private static final String KEY_GRAYSCALE = "daltonizer_mode_grayscale"; @VisibleForTesting static final String KEY_SATURATION = "daltonizer_saturation"; - private static final List sControllers = new ArrayList<>(); - - private static List buildPreferenceControllers(Context context, - Lifecycle lifecycle) { - if (sControllers.size() == 0) { - final Resources resources = context.getResources(); - final String[] daltonizerKeys = resources.getStringArray( - R.array.daltonizer_mode_keys); - - for (String daltonizerKey : daltonizerKeys) { - sControllers.add(new DaltonizerRadioButtonPreferenceController( - context, lifecycle, daltonizerKey)); - } - } - return sControllers; - } - @Override protected void registerKeysToObserverCallback( AccessibilitySettingsContentObserver contentObserver) { @@ -117,13 +90,6 @@ public class ToggleDaltonizerPreferenceFragment extends ToggleFeaturePreferenceF } } - @Override - public void onCheckedChanged(Preference preference) { - for (AbstractPreferenceController controller : sControllers) { - controller.updateState(preference); - } - } - private void updateFooterPreference() { final String title = getPrefContext() .getString(R.string.accessibility_daltonizer_about_title); @@ -155,21 +121,6 @@ public class ToggleDaltonizerPreferenceFragment extends ToggleFeaturePreferenceF public void onResume() { super.onResume(); updateSwitchBarToggleSwitch(); - for (AbstractPreferenceController controller : - buildPreferenceControllers(getPrefContext(), getSettingsLifecycle())) { - ((DaltonizerRadioButtonPreferenceController) controller).setOnChangeListener(this); - ((DaltonizerRadioButtonPreferenceController) controller).displayPreference( - getPreferenceScreen()); - } - } - - @Override - public void onPause() { - for (AbstractPreferenceController controller : - buildPreferenceControllers(getPrefContext(), getSettingsLifecycle())) { - ((DaltonizerRadioButtonPreferenceController) controller).setOnChangeListener(null); - } - super.onPause(); } @Override diff --git a/tests/robotests/src/com/android/settings/accessibility/DaltonizerRadioButtonPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/DaltonizerRadioButtonPreferenceControllerTest.java index 28954c5a993..56c08424050 100644 --- a/tests/robotests/src/com/android/settings/accessibility/DaltonizerRadioButtonPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/DaltonizerRadioButtonPreferenceControllerTest.java @@ -18,61 +18,65 @@ package com.android.settings.accessibility; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - import android.content.Context; import android.provider.Settings; -import androidx.preference.Preference; +import androidx.lifecycle.LifecycleOwner; +import androidx.preference.PreferenceManager; 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.settingslib.widget.SelectorWithWidgetPreference; +import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; +import org.robolectric.shadows.ShadowLooper; +/** + * Tests for {@link DaltonizerRadioButtonPreferenceController} + */ @RunWith(RobolectricTestRunner.class) -public class DaltonizerRadioButtonPreferenceControllerTest implements - DaltonizerRadioButtonPreferenceController.OnChangeListener { - private static final String PREF_KEY = "daltonizer_mode_protanomaly"; - private static final String PREF_VALUE = "11"; - private static final String PREF_FAKE_VALUE = "-1"; +public class DaltonizerRadioButtonPreferenceControllerTest { + private static final int DALTONIZER_MODE_INDEX = 0; + private static final String PREF_INVALID_VALUE = "-1"; + private final Context mContext = ApplicationProvider.getApplicationContext(); + private final String mPrefKey = + mContext.getResources() + .getStringArray(R.array.daltonizer_mode_keys)[DALTONIZER_MODE_INDEX]; + private final String mPrefValue = + String.valueOf(mContext.getResources() + .getIntArray(R.array.daltonizer_type_values)[DALTONIZER_MODE_INDEX]); private DaltonizerRadioButtonPreferenceController mController; - - @Mock - private SelectorWithWidgetPreference mMockPref; - private Context mContext; - - @Mock + private SelectorWithWidgetPreference mPreference; private PreferenceScreen mScreen; + private LifecycleOwner mLifecycleOwner; + private Lifecycle mLifecycle; + @Before public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = RuntimeEnvironment.application; - mController = new DaltonizerRadioButtonPreferenceController(mContext, mock(Lifecycle.class), - PREF_KEY); - mController.setOnChangeListener(this); - - when(mScreen.findPreference(mController.getPreferenceKey())).thenReturn(mMockPref); - when(mMockPref.getKey()).thenReturn(PREF_KEY); + // initialize the value as unchecked + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, PREF_INVALID_VALUE); + mController = new DaltonizerRadioButtonPreferenceController(mContext, mPrefKey); + mPreference = new SelectorWithWidgetPreference(mContext); + mPreference.setKey(mPrefKey); + mScreen = new PreferenceManager(mContext).createPreferenceScreen(mContext); + mScreen.addPreference(mPreference); mController.displayPreference(mScreen); + mLifecycleOwner = () -> mLifecycle; + mLifecycle = new Lifecycle(mLifecycleOwner); } - @Override - public void onCheckedChanged(Preference preference) { - mController.updateState(preference); + @After + public void cleanUp() { + mLifecycle.removeObserver(mController); } @Test @@ -81,36 +85,62 @@ public class DaltonizerRadioButtonPreferenceControllerTest implements } @Test - public void updateState_notChecked() { + public void updateState_valueNotMatched_notChecked() { Settings.Secure.putString(mContext.getContentResolver(), - Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, PREF_FAKE_VALUE); + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, PREF_INVALID_VALUE); - mController.updateState(mMockPref); + mController.updateState(mPreference); - // the first checked state is set to false by control - verify(mMockPref, atLeastOnce()).setChecked(false); - verify(mMockPref, never()).setChecked(true); + assertThat(mPreference.isChecked()).isFalse(); } @Test - public void updateState_checked() { + public void updateState_valueMatched_checked() { Settings.Secure.putString(mContext.getContentResolver(), - Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, PREF_VALUE); + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, mPrefValue); - mController.updateState(mMockPref); + mController.updateState(mPreference); - // the first checked state is set to false by control - verify(mMockPref, atLeastOnce()).setChecked(false); - verify(mMockPref, atLeastOnce()).setChecked(true); + assertThat(mPreference.isChecked()).isTrue(); } @Test public void onRadioButtonClick_shouldReturnDaltonizerValue() { - mController.onRadioButtonClicked(mMockPref); + mController.onRadioButtonClicked(mPreference); + final String accessibilityDaltonizerValue = Settings.Secure.getString( mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER); + assertThat(accessibilityDaltonizerValue).isEqualTo(mPrefValue); + } - assertThat(accessibilityDaltonizerValue).isEqualTo(PREF_VALUE); + @Test + public void onResume_settingsValueChangedToUnmatch_preferenceBecomesUnchecked() { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, mPrefValue); + mController.updateState(mPreference); + assertThat(mPreference.isChecked()).isTrue(); + mLifecycle.addObserver(mController); + + mLifecycle.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_RESUME); + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, PREF_INVALID_VALUE); + ShadowLooper.idleMainLooper(); + + assertThat(mPreference.isChecked()).isFalse(); + } + + @Test + public void onPause_settingsValueChangedAndMatch_preferenceStateNotUpdated() { + assertThat(mPreference.isChecked()).isFalse(); + mLifecycle.addObserver(mController); + mLifecycle.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_RESUME); + + mLifecycle.handleLifecycleEvent(androidx.lifecycle.Lifecycle.Event.ON_PAUSE); + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER, mPrefValue); + ShadowLooper.idleMainLooper(); + + assertThat(mPreference.isChecked()).isFalse(); } } diff --git a/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java b/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java index 850d1d79e09..a5bfec2f0db 100644 --- a/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/ToggleDaltonizerPreferenceFragmentTest.java @@ -18,53 +18,34 @@ package com.android.settings.accessibility; import static com.android.settings.accessibility.AccessibilityUtil.State.OFF; import static com.android.settings.accessibility.AccessibilityUtil.State.ON; -import static com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment.KEY_DEUTERANOMALY; -import static com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment.KEY_GRAYSCALE; -import static com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment.KEY_PROTANOMALY; -import static com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment.KEY_TRITANOMEALY; import static com.android.settings.accessibility.ToggleDaltonizerPreferenceFragment.KEY_USE_SERVICE_PREFERENCE; import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.when; - import android.app.settings.SettingsEnums; -import android.content.ComponentName; import android.content.Context; +import android.content.Intent; import android.os.Bundle; import android.platform.test.annotations.DisableFlags; import android.platform.test.flag.junit.SetFlagsRule; import android.provider.Settings; -import android.view.LayoutInflater; -import android.view.View; -import android.view.ViewGroup; import android.view.accessibility.Flags; import android.widget.PopupWindow; -import androidx.fragment.app.FragmentActivity; -import androidx.preference.PreferenceManager; -import androidx.preference.PreferenceScreen; +import androidx.fragment.app.Fragment; import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; -import com.android.settings.accessibility.AccessibilityUtil.QuickSettingsTooltipType; +import com.android.settings.SettingsActivity; import com.android.settings.testutils.XmlTestUtils; -import com.android.settings.testutils.shadow.ShadowFragment; import com.android.settings.widget.SettingsMainSwitchPreference; -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.Answers; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; -import org.robolectric.annotation.Config; +import org.robolectric.android.controller.ActivityController; import org.robolectric.shadow.api.Shadow; import org.robolectric.shadows.ShadowApplication; @@ -72,89 +53,52 @@ import java.util.List; /** Tests for {@link ToggleDaltonizerPreferenceFragment} */ @RunWith(RobolectricTestRunner.class) -@Config(shadows = ShadowFragment.class) public class ToggleDaltonizerPreferenceFragmentTest { @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(); private final Context mContext = ApplicationProvider.getApplicationContext(); - private TestToggleDaltonizerPreferenceFragment mFragment; - private PreferenceScreen mScreen; - private SettingsMainSwitchPreference mSwitchPreference; - - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - private PreferenceManager mPreferenceManager; - @Mock - private SelectorWithWidgetPreference mMockDeuteranomalyPref; - @Mock - private SelectorWithWidgetPreference mMockProtanomalyPref; - @Mock - private SelectorWithWidgetPreference mMockTritanomalyPref; - @Mock - private SelectorWithWidgetPreference mMockGrayscalePref; - @Mock - private FragmentActivity mActivity; + private ActivityController mActivityController; @Before - public void setUpTestFragment() { - MockitoAnnotations.initMocks(this); + public void setUp() { + Intent intent = new Intent(); + intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, + ToggleDaltonizerPreferenceFragment.class.getName()); + intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, new Bundle()); - mFragment = spy(new TestToggleDaltonizerPreferenceFragment(mContext)); - when(mFragment.getPreferenceManager()).thenReturn(mPreferenceManager); - when(mFragment.getPreferenceManager().getContext()).thenReturn(mContext); - when(mFragment.getContext()).thenReturn(mContext); - when(mFragment.getActivity()).thenReturn(mActivity); - when(mActivity.getContentResolver()).thenReturn(mContext.getContentResolver()); - - mScreen = spy(new PreferenceScreen(mContext, /* attrs= */ null)); - when(mScreen.findPreference(KEY_USE_SERVICE_PREFERENCE)) - .thenReturn(mFragment.mToggleServiceSwitchPreference); - when(mScreen.findPreference(KEY_DEUTERANOMALY)).thenReturn(mMockDeuteranomalyPref); - when(mMockDeuteranomalyPref.getKey()).thenReturn(KEY_DEUTERANOMALY); - when(mScreen.findPreference(KEY_PROTANOMALY)).thenReturn(mMockProtanomalyPref); - when(mMockProtanomalyPref.getKey()).thenReturn(KEY_PROTANOMALY); - when(mScreen.findPreference(KEY_TRITANOMEALY)).thenReturn(mMockTritanomalyPref); - when(mMockTritanomalyPref.getKey()).thenReturn(KEY_TRITANOMEALY); - when(mScreen.findPreference(KEY_GRAYSCALE)).thenReturn(mMockGrayscalePref); - when(mMockGrayscalePref.getKey()).thenReturn(KEY_GRAYSCALE); - when(mScreen.getPreferenceManager()).thenReturn(mPreferenceManager); - doReturn(mScreen).when(mFragment).getPreferenceScreen(); - - mSwitchPreference = mScreen.findPreference(KEY_USE_SERVICE_PREFERENCE); + mActivityController = ActivityController.of(new SettingsActivity(), intent); } @Test public void onResume_colorCorrectEnabled_shouldReturnTrue() { Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, ON); - mFragment.onAttach(mContext); - mFragment.onCreate(Bundle.EMPTY); - mFragment.onResume(); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); - assertThat(mSwitchPreference.isChecked()).isTrue(); + SettingsMainSwitchPreference switchPreference = getMainFeatureToggle(fragment); + assertThat(switchPreference.isChecked()).isTrue(); } @Test public void onResume_colorCorrectDisabled_shouldReturnFalse() { Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, OFF); - mFragment.onAttach(mContext); - mFragment.onCreate(Bundle.EMPTY); - mFragment.onResume(); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); - assertThat(mSwitchPreference.isChecked()).isFalse(); + SettingsMainSwitchPreference switchPreference = getMainFeatureToggle(fragment); + assertThat(switchPreference.isChecked()).isFalse(); } @Test public void onResume_colorCorrectEnabled_switchPreferenceChecked_notShowTooltips() { Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, ON); - mSwitchPreference.setChecked(true); - mFragment.onAttach(mContext); - mFragment.onCreate(Bundle.EMPTY); - mFragment.onResume(); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + SettingsMainSwitchPreference switchPreference = getMainFeatureToggle(fragment); + assertThat(switchPreference.isChecked()).isTrue(); assertThat(getLatestPopupWindow()).isNull(); } @@ -164,12 +108,10 @@ public class ToggleDaltonizerPreferenceFragmentTest { public void onPreferenceToggled_colorCorrectDisabled_shouldReturnTrueAndShowTooltipView() { Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, OFF); - mSwitchPreference.setChecked(false); - mFragment.onAttach(mContext); - mFragment.onCreateView(LayoutInflater.from(mContext), mock(ViewGroup.class), Bundle.EMPTY); - mFragment.onViewCreated(mFragment.getView(), Bundle.EMPTY); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + SettingsMainSwitchPreference switchPreference = getMainFeatureToggle(fragment); - mFragment.onPreferenceToggled(mSwitchPreference.getKey(), true); + fragment.onPreferenceToggled(switchPreference.getKey(), true); final boolean isEnabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, OFF) == ON; @@ -182,11 +124,10 @@ public class ToggleDaltonizerPreferenceFragmentTest { public void onPreferenceToggled_colorCorrectEnabled_shouldReturnFalseAndNotShowTooltipView() { Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, ON); - mSwitchPreference.setChecked(true); - mFragment.onAttach(mContext); - mFragment.onCreate(Bundle.EMPTY); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + SettingsMainSwitchPreference switchPreference = getMainFeatureToggle(fragment); - mFragment.onPreferenceToggled(mSwitchPreference.getKey(), false); + fragment.onPreferenceToggled(switchPreference.getKey(), false); final boolean isEnabled = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED, OFF) == ON; @@ -196,19 +137,25 @@ public class ToggleDaltonizerPreferenceFragmentTest { @Test public void getMetricsCategory_returnsCorrectCategory() { - assertThat(mFragment.getMetricsCategory()).isEqualTo( + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + + assertThat(fragment.getMetricsCategory()).isEqualTo( SettingsEnums.ACCESSIBILITY_TOGGLE_DALTONIZER); } @Test public void getPreferenceScreenResId_returnsCorrectXml() { - assertThat(mFragment.getPreferenceScreenResId()).isEqualTo( + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + + assertThat(fragment.getPreferenceScreenResId()).isEqualTo( R.xml.accessibility_daltonizer_settings); } @Test public void getHelpResource_returnsCorrectHelpResource() { - assertThat(mFragment.getHelpResource()).isEqualTo(R.string.help_url_color_correction); + ToggleDaltonizerPreferenceFragment fragment = getFragmentInResumedState(); + + assertThat(fragment.getHelpResource()).isEqualTo(R.string.help_url_color_correction); } @Test @@ -228,55 +175,20 @@ public class ToggleDaltonizerPreferenceFragmentTest { return shadowApplication.getLatestPopupWindow(); } - private static class TestToggleDaltonizerPreferenceFragment extends - ToggleDaltonizerPreferenceFragment { - private static final String PLACEHOLDER_PACKAGE_NAME = "com.placeholder.example"; - private static final String PLACEHOLDER_CLASS_NAME = - PLACEHOLDER_PACKAGE_NAME + ".placeholder"; - private static final ComponentName PLACEHOLDER_COMPONENT_NAME = new ComponentName( - PLACEHOLDER_PACKAGE_NAME, PLACEHOLDER_CLASS_NAME); - private static final String PLACEHOLDER_TILE_TOOLTIP_CONTENT = - PLACEHOLDER_PACKAGE_NAME + "tooltip_content"; + private ToggleDaltonizerPreferenceFragment getFragmentInResumedState() { - TestToggleDaltonizerPreferenceFragment(Context context) { - super(); - mComponentName = PLACEHOLDER_COMPONENT_NAME; - final SettingsMainSwitchPreference switchPreference = - new SettingsMainSwitchPreference(context); - switchPreference.setKey(KEY_USE_SERVICE_PREFERENCE); - mToggleServiceSwitchPreference = switchPreference; - setArguments(new Bundle()); - } + mActivityController.create().start().resume(); + Fragment fragment = mActivityController.get().getSupportFragmentManager().findFragmentById( + R.id.main_content); - @Override - public void onViewCreated(View view, Bundle savedInstanceState) { - // do nothing - } + assertThat(fragment).isNotNull(); + assertThat(fragment).isInstanceOf(ToggleDaltonizerPreferenceFragment.class); - @Override - public View onCreateView(LayoutInflater inflater, ViewGroup container, - Bundle savedInstanceState) { - return mock(View.class); - } + return (ToggleDaltonizerPreferenceFragment) fragment; + } - @Override - protected void updateShortcutPreference() { - // UI related function, do nothing in tests - } - - @Override - ComponentName getTileComponentName() { - return PLACEHOLDER_COMPONENT_NAME; - } - - @Override - protected CharSequence getTileTooltipContent(@QuickSettingsTooltipType int type) { - return PLACEHOLDER_TILE_TOOLTIP_CONTENT; - } - - @Override - public View getView() { - return mock(View.class); - } + private SettingsMainSwitchPreference getMainFeatureToggle( + ToggleDaltonizerPreferenceFragment fragment) { + return fragment.findPreference(KEY_USE_SERVICE_PREFERENCE); } }