Merge "MagnificationPreferenceFragment use DashboardFragment" into pi-dev

res/xml/accessibility_magnification_settings.xml

@@ -14,14 +14,17 @@
      limitations under the License.
 -->
 <PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+                  xmlns:settings="http://schemas.android.com/apk/res-auto"
                   android:key="magnification_preference_screen_title"
                   android:title="@string/accessibility_screen_magnification_title">
     <Preference
         android:fragment="com.android.settings.accessibility.ToggleScreenMagnificationPreferenceFragment"
         android:key="screen_magnification_gestures_preference_screen"
-        android:title="@string/accessibility_screen_magnification_gestures_title"/>
+        android:title="@string/accessibility_screen_magnification_gestures_title"
+        settings:controller="com.android.settings.accessibility.MagnificationGesturesPreferenceController"/>
     <Preference
         android:fragment="com.android.settings.accessibility.ToggleScreenMagnificationPreferenceFragment"
         android:key="screen_magnification_navbar_preference_screen"
-        android:title="@string/accessibility_screen_magnification_navbar_title"/>
+        android:title="@string/accessibility_screen_magnification_navbar_title"
+        settings:controller="com.android.settings.accessibility.MagnificationNavbarPreferenceController"/>
 </PreferenceScreen>

src/com/android/settings/accessibility/AccessibilitySettings.java

@@ -813,8 +813,8 @@ public class AccessibilitySettings extends SettingsPreferenceFragment implements
         if (!MagnificationPreferenceFragment.isApplicable(context.getResources())) {
             preference.setFragment(ToggleScreenMagnificationPreferenceFragment.class.getName());
             final Bundle extras = preference.getExtras();
-            MagnificationPreferenceFragment.populateMagnificationGesturesPreferenceExtras(extras,
+            MagnificationGesturesPreferenceController
-                    context);
+                    .populateMagnificationGesturesPreferenceExtras(extras, context);
         }
     }
 

src/com/android/settings/accessibility/AccessibilitySettingsForSetupWizard.java

@@ -156,8 +156,8 @@ public class AccessibilitySettingsForSetupWizard extends SettingsPreferenceFragm
             preference.setFragment(
                     ToggleScreenMagnificationPreferenceFragmentForSetupWizard.class.getName());
             final Bundle extras = preference.getExtras();
-            MagnificationPreferenceFragment.populateMagnificationGesturesPreferenceExtras(extras,
+            MagnificationGesturesPreferenceController
-                    context);
+                    .populateMagnificationGesturesPreferenceExtras(extras, context);
         }
     }
 }

src/com/android/settings/accessibility/MagnificationGesturesPreferenceController.java

@@ -0,0 +1,80 @@
+/*
+ * 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.accessibility;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+
+public class MagnificationGesturesPreferenceController extends BasePreferenceController {
+
+    private boolean mIsFromSUW = false;
+
+    public MagnificationGesturesPreferenceController(Context context, String key) {
+        super(context, key);
+    }
+
+    public void setIsFromSUW(boolean fromSUW) {
+        mIsFromSUW = fromSUW;
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (getPreferenceKey().equals(preference.getKey())) {
+            Bundle extras = preference.getExtras();
+            populateMagnificationGesturesPreferenceExtras(extras, mContext);
+            extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mIsFromSUW);
+        }
+        return false;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        int resId = 0;
+        if (mIsFromSUW) {
+            resId = R.string.accessibility_screen_magnification_short_summary;
+        } else {
+            final boolean enabled = Settings.Secure.getInt(mContext.getContentResolver(),
+                    Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1;
+            resId = (enabled ? R.string.accessibility_feature_state_on :
+                    R.string.accessibility_feature_state_off);
+        }
+        return mContext.getString(resId);
+    }
+
+    static void populateMagnificationGesturesPreferenceExtras(Bundle extras, Context context) {
+        extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED);
+        extras.putString(AccessibilitySettings.EXTRA_TITLE, context.getString(
+                R.string.accessibility_screen_magnification_gestures_title));
+        extras.putInt(AccessibilitySettings.EXTRA_TITLE_RES,
+                R.string.accessibility_screen_magnification_gestures_title);
+        extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY, context.getResources().getText(
+                R.string.accessibility_screen_magnification_summary));
+        extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
+                Settings.Secure.getInt(context.getContentResolver(),
+                        Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1);
+        extras.putInt(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID,
+                R.raw.accessibility_screen_magnification);
+    }
+}

src/com/android/settings/accessibility/MagnificationNavbarPreferenceController.java

@@ -0,0 +1,78 @@
+/*
+ * 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.accessibility;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+
+public class MagnificationNavbarPreferenceController extends BasePreferenceController {
+
+    private boolean mIsFromSUW = false;
+
+    public MagnificationNavbarPreferenceController(Context context, String key) {
+        super(context, key);
+    }
+
+    public void setIsFromSUW(boolean fromSUW) {
+        mIsFromSUW = fromSUW;
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (getPreferenceKey().equals(preference.getKey())) {
+            Bundle extras = preference.getExtras();
+            extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
+                    Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED);
+            extras.putString(AccessibilitySettings.EXTRA_TITLE, mContext.getString(
+                    R.string.accessibility_screen_magnification_navbar_title));
+            extras.putInt(AccessibilitySettings.EXTRA_TITLE_RES,
+                    R.string.accessibility_screen_magnification_navbar_title);
+            extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY,
+                    mContext.getResources().getText(
+                            R.string.accessibility_screen_magnification_navbar_summary));
+            extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
+                    Settings.Secure.getInt(mContext.getContentResolver(),
+                            Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0)
+                            == 1);
+            extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mIsFromSUW);
+        }
+        return false;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return MagnificationPreferenceFragment.isApplicable(mContext.getResources())
+                ? AVAILABLE
+                : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        int resId = 0;
+        if (mIsFromSUW) {
+            resId = R.string.accessibility_screen_magnification_navbar_short_summary;
+        } else {
+            final boolean enabled = Settings.Secure.getInt(mContext.getContentResolver(),
+                    Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0) == 1;
+            resId = (enabled ? R.string.accessibility_feature_state_on :
+                    R.string.accessibility_feature_state_off);
+        }
+        return mContext.getText(resId);
+    }
+}

src/com/android/settings/accessibility/MagnificationPreferenceFragment.java

@@ -29,40 +29,39 @@ import android.view.View;
 import android.view.accessibility.AccessibilityManager;
 
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.R;
 import com.android.settings.SettingsPreferenceFragment;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.search.Indexable;
+import com.android.settingslib.core.AbstractPreferenceController;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-public final class MagnificationPreferenceFragment extends SettingsPreferenceFragment implements
+public final class MagnificationPreferenceFragment extends DashboardFragment {
-        Indexable {
+
+    private static final String TAG = "MagnificationPreferenceFragment";
 
     // Settings App preference keys
     private static final String PREFERENCE_TITLE_KEY = "magnification_preference_screen_title";
-    private static final String MAGNIFICATION_GESTURES_PREFERENCE_SCREEN_KEY =
-            "screen_magnification_gestures_preference_screen";
-    private static final String MAGNIFICATION_NAVBAR_PREFERENCE_SCREEN_KEY =
-            "screen_magnification_navbar_preference_screen";
 
     // Pseudo ComponentName used to represent navbar magnification in Settings.Secure.
     private static final String MAGNIFICATION_COMPONENT_ID =
             "com.android.server.accessibility.MagnificationController";
 
-    private Preference mMagnificationGesturesPreference;
-    private Preference mMagnificationNavbarPreference;
-
     private boolean mLaunchedFromSuw = false;
 
     @Override
-    public void onCreatePreferences(Bundle bundle, String s) {
+    public int getMetricsCategory() {
-        addPreferencesFromResource(R.xml.accessibility_magnification_settings);
+        return MetricsEvent.ACCESSIBILITY_SCREEN_MAGNIFICATION_SETTINGS;
-        mMagnificationGesturesPreference = findPreference(
+    }
-                MAGNIFICATION_GESTURES_PREFERENCE_SCREEN_KEY);
+
-        mMagnificationNavbarPreference = findPreference(MAGNIFICATION_NAVBAR_PREFERENCE_SCREEN_KEY);
+    @Override
+    protected String getLogTag() {
+        return TAG;
     }
 
     @Override
@@ -71,28 +70,21 @@ public final class MagnificationPreferenceFragment extends SettingsPreferenceFra
     }
 
     @Override
-    public void onViewCreated(View view, Bundle savedInstanceState) {
+    protected int getPreferenceScreenResId() {
-        super.onViewCreated(view, savedInstanceState);
+        return R.xml.accessibility_magnification_settings;
+    }
 
+    @Override
+    public void onAttach(Context context) {
+        super.onAttach(context);
         final Bundle args = getArguments();
         if ((args != null) && args.containsKey(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW)) {
             mLaunchedFromSuw = args.getBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW);
         }
-    }
+        use(MagnificationGesturesPreferenceController.class)
-
+                .setIsFromSUW(mLaunchedFromSuw);
-    @Override
+        use(MagnificationNavbarPreferenceController.class)
-    public void onResume() {
+                .setIsFromSUW(mLaunchedFromSuw);
-        super.onResume();
-        getActivity().setTitle(R.string.accessibility_screen_magnification_title);
-        updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED,
-                mMagnificationGesturesPreference);
-        updateFeatureSummary(Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED,
-                mMagnificationNavbarPreference);
-    }
-
-    @Override
-    public int getMetricsCategory() {
-        return MetricsEvent.ACCESSIBILITY_SCREEN_MAGNIFICATION_SETTINGS;
     }
 
     @Override
@@ -102,57 +94,9 @@ public final class MagnificationPreferenceFragment extends SettingsPreferenceFra
             preference.setFragment(
                     ToggleScreenMagnificationPreferenceFragmentForSetupWizard.class.getName());
         }
-        if (mMagnificationGesturesPreference == preference) {
-            handleMagnificationGesturesPreferenceScreenClick();
-            super.onPreferenceTreeClick(mMagnificationGesturesPreference);
-            return true;
-        } else if (mMagnificationNavbarPreference == preference) {
-            handleMagnificationNavbarPreferenceScreenClick();
-            super.onPreferenceTreeClick(mMagnificationNavbarPreference);
-            return true;
-        }
         return super.onPreferenceTreeClick(preference);
     }
 
-    private void updateFeatureSummary(String prefKey, Preference pref) {
-        if (!mLaunchedFromSuw) {
-            final boolean enabled = Settings.Secure.getInt(getContentResolver(), prefKey, 0) == 1;
-            pref.setSummary(enabled ? R.string.accessibility_feature_state_on
-                    : R.string.accessibility_feature_state_off);
-        } else {
-            if (Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED.equals(prefKey)) {
-                pref.setSummary(R.string.accessibility_screen_magnification_short_summary);
-            } else if (Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED.equals(
-                    prefKey)) {
-                pref.setSummary(R.string.accessibility_screen_magnification_navbar_short_summary);
-            }
-        }
-    }
-
-    private void handleMagnificationGesturesPreferenceScreenClick() {
-        Bundle extras = mMagnificationGesturesPreference.getExtras();
-        populateMagnificationGesturesPreferenceExtras(extras, getContext());
-        extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mLaunchedFromSuw);
-    }
-
-    private void handleMagnificationNavbarPreferenceScreenClick() {
-        Bundle extras = mMagnificationNavbarPreference.getExtras();
-        extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
-                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED);
-        extras.putString(AccessibilitySettings.EXTRA_TITLE, getString(
-                R.string.accessibility_screen_magnification_navbar_title));
-        extras.putInt(AccessibilitySettings.EXTRA_TITLE_RES,
-                R.string.accessibility_screen_magnification_navbar_title);
-        extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY,
-                getActivity().getResources().getText(
-                        R.string.accessibility_screen_magnification_navbar_summary));
-        extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
-                Settings.Secure.getInt(getContentResolver(),
-                        Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0)
-                        == 1);
-        extras.putBoolean(AccessibilitySettings.EXTRA_LAUNCHED_FROM_SUW, mLaunchedFromSuw);
-    }
-
     static CharSequence getConfigurationWarningStringForSecureSettingsKey(String key,
             Context context) {
         if (!Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED.equals(key)) {
@@ -187,22 +131,6 @@ public final class MagnificationPreferenceFragment extends SettingsPreferenceFra
         return null;
     }
 
-    static void populateMagnificationGesturesPreferenceExtras(Bundle extras, Context context) {
-        extras.putString(AccessibilitySettings.EXTRA_PREFERENCE_KEY,
-                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED);
-        extras.putString(AccessibilitySettings.EXTRA_TITLE, context.getString(
-                R.string.accessibility_screen_magnification_gestures_title));
-        extras.putInt(AccessibilitySettings.EXTRA_TITLE_RES,
-                R.string.accessibility_screen_magnification_gestures_title);
-        extras.putCharSequence(AccessibilitySettings.EXTRA_SUMMARY, context.getResources().getText(
-                R.string.accessibility_screen_magnification_summary));
-        extras.putBoolean(AccessibilitySettings.EXTRA_CHECKED,
-                Settings.Secure.getInt(context.getContentResolver(),
-                        Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0) == 1);
-        extras.putInt(AccessibilitySettings.EXTRA_VIDEO_RAW_RESOURCE_ID,
-                R.raw.accessibility_screen_magnification);
-    }
-
     /**
      * @return {@code true} if this fragment should be shown, {@code false} otherwise. This
      * fragment is shown in the case that more than one magnification mode is available.

tests/robotests/src/com/android/settings/accessibility/MagnificationGesturesPreferenceControllerTest.java

@@ -0,0 +1,80 @@
+/*
+ * 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.accessibility;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+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 MagnificationGesturesPreferenceControllerTest {
+
+    private Context mContext;
+    private MagnificationGesturesPreferenceController mController;
+    private Preference mPreference;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = RuntimeEnvironment.application;
+        mController = new MagnificationGesturesPreferenceController(mContext, "pref_key");
+        mPreference = new Preference(mContext);
+        mController.updateState(mPreference);
+    }
+
+    @Test
+    public void isAlwaysAvailable() {
+        assertThat(mController.getAvailabilityStatus())
+                .isEqualTo(BasePreferenceController.AVAILABLE);
+    }
+
+    @Test
+    public void updateState_shouldRefreshSummary() {
+        Settings.System.putInt(mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 1);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getString(R.string.accessibility_feature_state_on));
+
+        Settings.System.putInt(mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 0);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getString(R.string.accessibility_feature_state_off));
+    }
+
+    @Test
+    public void updateState_shouldRefreshSummarySuw() {
+        mController.setIsFromSUW(true);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getString(R.string.
+                        accessibility_screen_magnification_short_summary));
+    }
+}

tests/robotests/src/com/android/settings/accessibility/MagnificationNavbarPreferenceControllerTest.java

@@ -0,0 +1,123 @@
+/*
+ * 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.accessibility;
+
+import static com.android.settings.search.ResultPayload.Availability.AVAILABLE;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.spy;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.provider.Settings;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.R;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+import org.robolectric.annotation.Resetter;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class MagnificationNavbarPreferenceControllerTest {
+
+    private Context mContext;
+    private MagnificationNavbarPreferenceController mController;
+    private Preference mPreference;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        mController = new MagnificationNavbarPreferenceController(mContext, "test_key");
+        mPreference = new Preference(mContext);
+        mController.updateState(mPreference);
+    }
+
+    @After
+    public void tearDown() {
+        ShadowMagnificationPreferenceFragment.reset();
+    }
+
+    @Test
+    @Config(shadows = ShadowMagnificationPreferenceFragment.class)
+    public void isAvailable_unsupported_shouldNotBeAvailable() {
+        ShadowMagnificationPreferenceFragment.setApplicable(false);
+
+        assertThat(mController.getAvailabilityStatus())
+                .isNotEqualTo(AVAILABLE);
+    }
+
+    @Test
+    @Config(shadows = ShadowMagnificationPreferenceFragment.class)
+    public void isAvailable_supported_shouldBeAvailable() {
+        ShadowMagnificationPreferenceFragment.setApplicable(true);
+
+        assertThat(mController.getAvailabilityStatus())
+                .isEqualTo(AVAILABLE);
+    }
+
+    @Test
+    public void updateState_shouldRefreshSummary() {
+        Settings.System.putInt(mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 1);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getText(R.string.accessibility_feature_state_on));
+
+        Settings.System.putInt(mContext.getContentResolver(),
+                Settings.Secure.ACCESSIBILITY_DISPLAY_MAGNIFICATION_NAVBAR_ENABLED, 0);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getText(R.string.accessibility_feature_state_off));
+    }
+
+    @Test
+    public void updateState_shouldRefreshSummarySuw() {
+        mController.setIsFromSUW(true);
+        mController.updateState(mPreference);
+        assertThat(mPreference.getSummary())
+                .isEqualTo(mContext.getString(R.string.
+                        accessibility_screen_magnification_navbar_short_summary));
+    }
+
+    @Implements(MagnificationPreferenceFragment.class)
+    public static class ShadowMagnificationPreferenceFragment {
+        private static boolean sIsApplicable;
+
+        @Resetter
+        static void reset() {
+            sIsApplicable = false;
+        }
+
+        @Implementation
+        static boolean isApplicable(Resources res) {
+            return sIsApplicable;
+        }
+
+        static void setApplicable(boolean applicable) {
+            sIsApplicable = applicable;
+        }
+    }
+}