Merge changes I502e52f6,Iabf58566,Ida773967,Ic6c48861,If9e5cc6e, ...

* changes:
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (15/n).
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (14/n).
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (13/n).
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (12/n).
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (11/n).
  New feature “Text and reading options” for SetupWizard, Wallpaper, and Settings (10/n).

src/com/android/settings/accessibility/DisplaySizeData.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 android.content.Context;
+import android.content.res.Resources;
+import android.view.Display;
+
+import com.android.settingslib.display.DisplayDensityConfiguration;
+import com.android.settingslib.display.DisplayDensityUtils;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.stream.Collectors;
+
+/**
+ * Data class for storing the configurations related to the display size.
+ */
+class DisplaySizeData extends PreviewSizeData<Integer> {
+    DisplaySizeData(Context context) {
+        super(context);
+
+        final DisplayDensityUtils density = new DisplayDensityUtils(getContext());
+        final int initialIndex = density.getCurrentIndex();
+        if (initialIndex < 0) {
+            // Failed to obtain default density, which means we failed to
+            // connect to the window manager service. Just use the current
+            // density and don't let the user change anything.
+            final Resources resources = getContext().getResources();
+            final int densityDpi = resources.getDisplayMetrics().densityDpi;
+            setDefaultValue(densityDpi);
+            setInitialIndex(0);
+            setValues(Collections.singletonList(densityDpi));
+        } else {
+            setDefaultValue(density.getDefaultDensity());
+            setInitialIndex(initialIndex);
+            setValues(Arrays.stream(density.getValues()).boxed().collect(Collectors.toList()));
+        }
+    }
+
+    @Override
+    void commit(int currentProgress) {
+        final int densityDpi = getValues().get(currentProgress);
+        if (densityDpi == getDefaultValue()) {
+            DisplayDensityConfiguration.clearForcedDisplayDensity(Display.DEFAULT_DISPLAY);
+        } else {
+            DisplayDensityConfiguration.setForcedDisplayDensity(Display.DEFAULT_DISPLAY,
+                    densityDpi);
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * 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.android.settings.display.ToggleFontSizePreferenceFragment.fontSizeValueToIndex;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.res.Resources;
+import android.provider.Settings;
+
+import com.android.settings.R;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Data class for storing the configurations related to the font size.
+ */
+final class FontSizeData extends PreviewSizeData<Float> {
+    private static final float FONT_SCALE_DEF_VALUE = 1.0f;
+
+    FontSizeData(Context context) {
+        super(context);
+
+        final Resources resources = getContext().getResources();
+        final ContentResolver resolver = getContext().getContentResolver();
+        final List<String> strEntryValues =
+                Arrays.asList(resources.getStringArray(R.array.entryvalues_font_size));
+        setDefaultValue(FONT_SCALE_DEF_VALUE);
+        final float currentScale =
+                Settings.System.getFloat(resolver, Settings.System.FONT_SCALE, getDefaultValue());
+        setInitialIndex(fontSizeValueToIndex(currentScale, strEntryValues.toArray(new String[0])));
+        setValues(strEntryValues.stream().map(Float::valueOf).collect(Collectors.toList()));
+    }
+
+    @Override
+    void commit(int currentProgress) {
+        final ContentResolver resolver = getContext().getContentResolver();
+        Settings.System.putFloat(resolver, Settings.System.FONT_SCALE,
+                getValues().get(currentProgress));
+    }
+}

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

@@ -24,7 +24,8 @@ import com.android.settings.R;
 import com.android.settings.core.TogglePreferenceController;
 
 /** PreferenceController for displaying all text in bold. */
-public class FontWeightAdjustmentPreferenceController extends TogglePreferenceController {
+public class FontWeightAdjustmentPreferenceController extends TogglePreferenceController implements
+        TextReadingResetController.ResetStateListener {
     static final int BOLD_TEXT_ADJUSTMENT =
             FontStyle.FONT_WEIGHT_BOLD - FontStyle.FONT_WEIGHT_NORMAL;
 
@@ -53,4 +54,9 @@ public class FontWeightAdjustmentPreferenceController extends TogglePreferenceCo
     public int getSliceHighlightMenuRes() {
         return R.string.menu_key_accessibility;
     }
+
+    @Override
+    public void resetState() {
+        setChecked(false);
+    }
 }

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

@@ -22,7 +22,11 @@ import android.provider.Settings;
 import com.android.settings.R;
 import com.android.settings.core.TogglePreferenceController;
 
-public class HighTextContrastPreferenceController extends TogglePreferenceController {
+/**
+ * PreferenceController for displaying all text in high contrast style.
+ */
+public class HighTextContrastPreferenceController extends TogglePreferenceController implements
+        TextReadingResetController.ResetStateListener {
 
     public HighTextContrastPreferenceController(Context context, String preferenceKey) {
         super(context, preferenceKey);
@@ -49,4 +53,9 @@ public class HighTextContrastPreferenceController extends TogglePreferenceContro
     public int getSliceHighlightMenuRes() {
         return R.string.menu_key_accessibility;
     }
+
+    @Override
+    public void resetState() {
+        setChecked(false);
+    }
 }

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

@@ -0,0 +1,71 @@
+/*
+ * 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.Context;
+
+import androidx.annotation.NonNull;
+
+import java.util.List;
+
+/**
+ * Abstract data class for storing and fetching the configurations related to the preview of the
+ * text and reading options.
+ */
+abstract class PreviewSizeData<T extends Number> {
+    private final Context mContext;
+    private int mInitialIndex;
+    private T mDefaultValue;
+    private List<T> mValues;
+
+    PreviewSizeData(@NonNull Context context) {
+        mContext = context;
+    }
+
+    Context getContext() {
+        return mContext;
+    }
+
+    List<T> getValues() {
+        return mValues;
+    }
+
+    void setValues(List<T> values) {
+        mValues = values;
+    }
+
+    T getDefaultValue() {
+        return mDefaultValue;
+    }
+
+    void setDefaultValue(T defaultValue) {
+        mDefaultValue = defaultValue;
+    }
+
+    int getInitialIndex() {
+        return mInitialIndex;
+    }
+
+    void setInitialIndex(int initialIndex) {
+        mInitialIndex = initialIndex;
+    }
+
+    /**
+     * Persists the selected size.
+     */
+    abstract void commit(int currentProgress);
+}

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

@@ -0,0 +1,119 @@
+/*
+ * 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.Context;
+import android.widget.SeekBar;
+
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.widget.LabeledSeekBarPreference;
+
+/**
+ * The controller of {@link LabeledSeekBarPreference} that listens to display size and font size
+ * settings changes and updates preview size threshold smoothly.
+ */
+class PreviewSizeSeekBarController extends BasePreferenceController implements
+        TextReadingResetController.ResetStateListener {
+    private final PreviewSizeData<? extends Number> mSizeData;
+    private boolean mSeekByTouch;
+    private ProgressInteractionListener mInteractionListener;
+    private LabeledSeekBarPreference mSeekBarPreference;
+
+    private final SeekBar.OnSeekBarChangeListener mSeekBarChangeListener =
+            new SeekBar.OnSeekBarChangeListener() {
+                @Override
+                public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+                    mInteractionListener.notifyPreferenceChanged();
+
+                    if (!mSeekByTouch && mInteractionListener != null) {
+                        mInteractionListener.onProgressChanged();
+                    }
+                }
+
+                @Override
+                public void onStartTrackingTouch(SeekBar seekBar) {
+                    mSeekByTouch = true;
+                }
+
+                @Override
+                public void onStopTrackingTouch(SeekBar seekBar) {
+                    mSeekByTouch = false;
+
+                    if (mInteractionListener != null) {
+                        mInteractionListener.onEndTrackingTouch();
+                    }
+                }
+            };
+
+    PreviewSizeSeekBarController(Context context, String preferenceKey,
+            @NonNull PreviewSizeData<? extends Number> sizeData) {
+        super(context, preferenceKey);
+        mSizeData = sizeData;
+    }
+
+    void setInteractionListener(ProgressInteractionListener interactionListener) {
+        mInteractionListener = interactionListener;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        final int dataSize = mSizeData.getValues().size();
+        final int initialIndex = mSizeData.getInitialIndex();
+        mSeekBarPreference = screen.findPreference(getPreferenceKey());
+        mSeekBarPreference.setMax(dataSize - 1);
+        mSeekBarPreference.setProgress(initialIndex);
+        mSeekBarPreference.setContinuousUpdates(true);
+        mSeekBarPreference.setOnSeekBarChangeListener(mSeekBarChangeListener);
+    }
+
+    @Override
+    public void resetState() {
+        final int defaultProgress = mSizeData.getValues().indexOf(mSizeData.getDefaultValue());
+        mSeekBarPreference.setProgress(defaultProgress);
+    }
+
+    /**
+     * Interface for callbacks when users interact with the seek bar.
+     */
+    interface ProgressInteractionListener {
+
+        /**
+         * Called when the progress is changed.
+         */
+        void notifyPreferenceChanged();
+
+        /**
+         * Called when the progress is changed without tracking touch.
+         */
+        void onProgressChanged();
+
+        /**
+         * Called when the seek bar is end tracking.
+         */
+        void onEndTrackingTouch();
+    }
+}

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

@@ -16,13 +16,21 @@
 
 package com.android.settings.accessibility;
 
+import static com.android.settings.accessibility.TextReadingResetController.ResetStateListener;
+
 import android.app.settings.SettingsEnums;
+import android.content.Context;
 
 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.search.SearchIndexable;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
  * Accessibility settings for adjusting the system features which are related to the reading. For
  * example, bold text, high contrast text, display size, font size and so on.
@@ -30,6 +38,12 @@ import com.android.settingslib.search.SearchIndexable;
 @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
 public class TextReadingPreferenceFragment extends DashboardFragment {
     private static final String TAG = "TextReadingPreferenceFragment";
+    private static final String FONT_SIZE_KEY = "font_size";
+    private static final String DISPLAY_SIZE_KEY = "display_size";
+    private static final String PREVIEW_KEY = "preview";
+    private static final String RESET_KEY = "reset";
+    private static final String BOLD_TEXT_KEY = "toggle_force_bold_text";
+    private static final String HIGHT_TEXT_CONTRAST_KEY = "toggle_high_text_contrast_preference";
 
     @Override
     protected int getPreferenceScreenResId() {
@@ -46,6 +60,44 @@ public class TextReadingPreferenceFragment extends DashboardFragment {
         return SettingsEnums.ACCESSIBILITY_TEXT_READING_OPTIONS;
     }
 
+    @Override
+    protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
+        final List<AbstractPreferenceController> controllers = new ArrayList<>();
+        final FontSizeData fontSizeData = new FontSizeData(context);
+        final DisplaySizeData displaySizeData = new DisplaySizeData(context);
+
+        final TextReadingPreviewController previewController = new TextReadingPreviewController(
+                context, PREVIEW_KEY, fontSizeData, displaySizeData);
+        controllers.add(previewController);
+
+        final PreviewSizeSeekBarController fontSizeController = new PreviewSizeSeekBarController(
+                context, FONT_SIZE_KEY, fontSizeData);
+        fontSizeController.setInteractionListener(previewController);
+        controllers.add(fontSizeController);
+
+        final PreviewSizeSeekBarController displaySizeController = new PreviewSizeSeekBarController(
+                context, DISPLAY_SIZE_KEY, displaySizeData);
+        displaySizeController.setInteractionListener(previewController);
+        controllers.add(displaySizeController);
+
+        final FontWeightAdjustmentPreferenceController fontWeightController =
+                new FontWeightAdjustmentPreferenceController(context, BOLD_TEXT_KEY);
+        controllers.add(fontWeightController);
+
+        final HighTextContrastPreferenceController highTextContrastController =
+                new HighTextContrastPreferenceController(context, HIGHT_TEXT_CONTRAST_KEY);
+        controllers.add(highTextContrastController);
+
+        final List<ResetStateListener> resetStateListeners =
+                controllers.stream().filter(c -> c instanceof ResetStateListener).map(
+                        c -> (ResetStateListener) c).collect(Collectors.toList());
+        final TextReadingResetController resetController =
+                new TextReadingResetController(context, RESET_KEY, resetStateListeners);
+        controllers.add(resetController);
+
+        return controllers;
+    }
+
     public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
             new BaseSearchIndexProvider(R.xml.accessibility_text_reading_options);
 }

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

@@ -0,0 +1,194 @@
+/*
+ * 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.Context;
+import android.content.res.Configuration;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+import com.android.settings.display.PreviewPagerAdapter;
+import com.android.settings.widget.LabeledSeekBarPreference;
+
+import java.util.Objects;
+
+/**
+ * A {@link BasePreferenceController} for controlling the preview pager of the text and reading
+ * options.
+ */
+class TextReadingPreviewController extends BasePreferenceController implements
+        PreviewSizeSeekBarController.ProgressInteractionListener {
+    static final int[] PREVIEW_SAMPLE_RES_IDS = new int[]{
+            R.layout.accessibility_text_reading_preview_app_grid,
+            R.layout.screen_zoom_preview_1,
+            R.layout.accessibility_text_reading_preview_mail_content};
+
+    private static final String PREVIEW_KEY = "preview";
+    private static final String FONT_SIZE_KEY = "font_size";
+    private static final String DISPLAY_SIZE_KEY = "display_size";
+    private static final long MIN_COMMIT_INTERVAL_MS = 800;
+    private static final long CHANGE_BY_SEEKBAR_DELAY_MS = 100;
+    private static final long CHANGE_BY_BUTTON_DELAY_MS = 300;
+    private final FontSizeData mFontSizeData;
+    private final DisplaySizeData mDisplaySizeData;
+    private int mLastFontProgress;
+    private int mLastDisplayProgress;
+    private long mLastCommitTime;
+    private TextReadingPreviewPreference mPreviewPreference;
+    private LabeledSeekBarPreference mFontSizePreference;
+    private LabeledSeekBarPreference mDisplaySizePreference;
+
+    private final Choreographer.FrameCallback mCommit = f -> {
+        tryCommitFontSizeConfig();
+        tryCommitDisplaySizeConfig();
+
+        mLastCommitTime = SystemClock.elapsedRealtime();
+    };
+
+    TextReadingPreviewController(Context context, String preferenceKey,
+            @NonNull FontSizeData fontSizeData, @NonNull DisplaySizeData displaySizeData) {
+        super(context, preferenceKey);
+        mFontSizeData = fontSizeData;
+        mDisplaySizeData = displaySizeData;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        mPreviewPreference = screen.findPreference(PREVIEW_KEY);
+
+        mFontSizePreference = screen.findPreference(FONT_SIZE_KEY);
+        mDisplaySizePreference = screen.findPreference(DISPLAY_SIZE_KEY);
+        Objects.requireNonNull(mFontSizePreference,
+                /* message= */ "Font size preference is null, the preview controller "
+                        + "couldn't get the info");
+        Objects.requireNonNull(mDisplaySizePreference,
+                /* message= */ "Display size preference is null, the preview controller"
+                        + " couldn't get the info");
+
+        mLastFontProgress = mFontSizePreference.getProgress();
+        mLastDisplayProgress = mDisplaySizePreference.getProgress();
+
+        final Configuration origConfig = mContext.getResources().getConfiguration();
+        final boolean isLayoutRtl =
+                origConfig.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL;
+        final PreviewPagerAdapter pagerAdapter = new PreviewPagerAdapter(mContext, isLayoutRtl,
+                PREVIEW_SAMPLE_RES_IDS, createConfig(origConfig));
+        mPreviewPreference.setPreviewAdapter(pagerAdapter);
+        pagerAdapter.setPreviewLayer(/* newLayerIndex= */ 0,
+                /* currentLayerIndex= */ 0,
+                /* currentFrameIndex= */ 0, /* animate= */ false);
+    }
+
+    @Override
+    public void notifyPreferenceChanged() {
+        final int displayDataSize = mDisplaySizeData.getValues().size();
+        final int fontSizeProgress = mFontSizePreference.getProgress();
+        final int displaySizeProgress = mDisplaySizePreference.getProgress();
+
+        // To be consistent with the
+        // {@link PreviewPagerAdapter#setPreviewLayer(int, int, int, boolean)} behavior,
+        // here also needs the same design. In addition, please also refer to
+        // the {@link #createConfig(Configuration)}.
+        final int pagerIndex = fontSizeProgress * displayDataSize + displaySizeProgress;
+
+        mPreviewPreference.notifyPreviewPagerChanged(pagerIndex);
+    }
+
+    @Override
+    public void onProgressChanged() {
+        postCommitDelayed(CHANGE_BY_BUTTON_DELAY_MS);
+    }
+
+    @Override
+    public void onEndTrackingTouch() {
+        postCommitDelayed(CHANGE_BY_SEEKBAR_DELAY_MS);
+    }
+
+    /**
+     * Avoids the flicker when switching to the previous or next level.
+     *
+     * <p><br>[Flickering problem steps] commit()-> snapshot in framework(old screenshot) ->
+     * app update the preview -> snapshot(old screen) fade out</p>
+     *
+     * <p><br>To prevent flickering problem, we make sure that we update the local preview
+     * first and then we do the commit later. </p>
+     *
+     * <p><br><b>Note:</b> It doesn't matter that we use
+     * Choreographer or main thread handler since the delay time is longer
+     * than 1 frame. Use Choreographer to let developer understand it's a
+     * window update.</p>
+     *
+     * @param commitDelayMs the interval time after a action.
+     */
+    void postCommitDelayed(long commitDelayMs) {
+        if (SystemClock.elapsedRealtime() - mLastCommitTime < MIN_COMMIT_INTERVAL_MS) {
+            commitDelayMs += MIN_COMMIT_INTERVAL_MS;
+        }
+
+        final Choreographer choreographer = Choreographer.getInstance();
+        choreographer.removeFrameCallback(mCommit);
+        choreographer.postFrameCallbackDelayed(mCommit, commitDelayMs);
+    }
+
+    private void tryCommitFontSizeConfig() {
+        final int fontProgress = mFontSizePreference.getProgress();
+        if (fontProgress != mLastFontProgress) {
+            mFontSizeData.commit(fontProgress);
+            mLastFontProgress = fontProgress;
+        }
+    }
+
+    private void tryCommitDisplaySizeConfig() {
+        final int displayProgress = mDisplaySizePreference.getProgress();
+        if (displayProgress != mLastDisplayProgress) {
+            mDisplaySizeData.commit(displayProgress);
+            mLastDisplayProgress = displayProgress;
+        }
+    }
+
+    private Configuration[] createConfig(Configuration origConfig) {
+        final int fontDataSize = mFontSizeData.getValues().size();
+        final int displayDataSize = mDisplaySizeData.getValues().size();
+        final int totalNum = fontDataSize * displayDataSize;
+        final Configuration[] configurations = new Configuration[totalNum];
+
+        for (int i = 0; i < fontDataSize; ++i) {
+            for (int j = 0; j < displayDataSize; ++j) {
+                final Configuration config = new Configuration(origConfig);
+                config.fontScale = mFontSizeData.getValues().get(i);
+                config.densityDpi = mDisplaySizeData.getValues().get(j);
+
+                configurations[i * displayDataSize + j] = config;
+            }
+        }
+
+        return configurations;
+    }
+}

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

@@ -32,8 +32,9 @@ import com.android.settings.widget.DotsPageIndicator;
 /**
  * A {@link Preference} that could show the preview related to the text and reading options.
  */
-final class TextReadingPreviewPreference extends Preference {
+public class TextReadingPreviewPreference extends Preference {
     private int mCurrentItem;
+    private int mLastLayerIndex;
     private PreviewPagerAdapter mPreviewAdapter;
 
     TextReadingPreviewPreference(Context context) {
@@ -41,7 +42,7 @@ final class TextReadingPreviewPreference extends Preference {
         init();
     }
 
-    TextReadingPreviewPreference(Context context, AttributeSet attrs) {
+    public TextReadingPreviewPreference(Context context, AttributeSet attrs) {
         super(context, attrs);
         init();
     }
@@ -120,4 +121,16 @@ final class TextReadingPreviewPreference extends Preference {
     private void init() {
         setLayoutResource(R.layout.accessibility_text_reading_preview);
     }
+
+    void notifyPreviewPagerChanged(int pagerIndex) {
+        Preconditions.checkNotNull(mPreviewAdapter,
+                "Preview adapter is null, you should init the preview adapter first");
+
+        if (pagerIndex != mLastLayerIndex) {
+            mPreviewAdapter.setPreviewLayer(pagerIndex, mLastLayerIndex, getCurrentItem(),
+                    /* animate= */ false);
+        }
+
+        mLastLayerIndex = pagerIndex;
+    }
 }

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

@@ -0,0 +1,66 @@
+/*
+ * 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.Context;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.core.BasePreferenceController;
+import com.android.settingslib.widget.LayoutPreference;
+
+import java.util.List;
+
+/**
+ * The controller of the reset button in the text and reading options page.
+ */
+class TextReadingResetController extends BasePreferenceController {
+    private final List<ResetStateListener> mListeners;
+
+    TextReadingResetController(Context context, String preferenceKey,
+            @NonNull List<ResetStateListener> listeners) {
+        super(context, preferenceKey);
+        mListeners = listeners;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+
+        final LayoutPreference layoutPreference = screen.findPreference(getPreferenceKey());
+        final View view = layoutPreference.findViewById(R.id.reset_button);
+        view.setOnClickListener(v -> mListeners.forEach(ResetStateListener::resetState));
+    }
+
+    /**
+     * Interface for resetting to default state.
+     */
+    interface ResetStateListener {
+        /**
+         * Called when the reset button was clicked.
+         */
+        void resetState();
+    }
+}

src/com/android/settings/display/PreviewPagerAdapter.java

@@ -117,7 +117,15 @@ public class PreviewPagerAdapter extends PagerAdapter {
         mAnimationEndAction = action;
     }
 
-    void setPreviewLayer(int newLayerIndex, int currentLayerIndex, int currentFrameIndex,
+    /**
+     * Switches the sample layouts for the preview pager.
+     *
+     * @param newLayerIndex the new layer index
+     * @param currentLayerIndex the current layer index
+     * @param currentFrameIndex the current frame index
+     * @param animate whether to enable the animation
+     */
+    public void setPreviewLayer(int newLayerIndex, int currentLayerIndex, int currentFrameIndex,
             final boolean animate) {
         for (FrameLayout previewFrame : mPreviewFrames) {
             if (currentLayerIndex >= 0) {