[RRS] show resolution option on Settings page.

Due to the special width/ height of the device, we have to modify the
available condition otherwise the resolution option cannot be shown on Settings.

Bug: 258346214
Test: Lunch Settings and check the Display page
Change-Id: I577e0e1227727aab75787c1f6115091e0c6158e1

res/values/config.xml

@@ -562,13 +562,7 @@
     <!-- The option list for switch screen resolution -->
     <string-array name="config_screen_resolution_options_strings" translatable="false">
         <item>@string/screen_resolution_option_high</item>
-        <item>@string/screen_resolution_option_highest</item>
+        <item>@string/screen_resolution_option_full</item>
-    </string-array>
-
-    <!-- The option summary list for screen resolution -->
-    <string-array name="config_screen_resolution_summaries_strings" translatable="false">
-        <item>@string/screen_resolution_summary_high</item>
-        <item>@string/screen_resolution_summary_highest</item>
     </string-array>
 
     <!-- Whether to aggregate for network selection list-->

res/values/strings.xml

@@ -2102,14 +2102,10 @@
 
     <!-- Display settings screen, screen resolution settings title [CHAR LIMIT=30] -->
     <string name="screen_resolution_title">Screen resolution</string>
-    <!-- Display settings screen, screen resolution option for "FHD+" [CHAR LIMIT=45] -->
+    <!-- Display settings screen, screen resolution option for high resolution [CHAR LIMIT=45] -->
     <string name="screen_resolution_option_high">High resolution</string>
-    <!-- Display settings screen, screen resolution option for "QHD+" [CHAR LIMIT=45] -->
+    <!-- Display settings screen, screen resolution option for full resolution [CHAR LIMIT=45] -->
-    <string name="screen_resolution_option_highest">Full resolution</string>
+    <string name="screen_resolution_option_full">Full resolution</string>
-    <!-- Display settings screen, "FHD+" screen resolution summary [CHAR LIMIT=NONE] -->
-    <string name="screen_resolution_summary_high">1080p FHD+</string>
-    <!-- Display settings screen, "QHD+" screen resolution summary [CHAR LIMIT=NONE] -->
-    <string name="screen_resolution_summary_highest">1440p QHD+</string>
     <!-- The footer message for switch screen resolution [CHAR LIMIT=NONE] -->
     <string name="screen_resolution_footer">Full resolution uses more of your battery. Switching your resolution may cause some apps to restart.</string>
     <!-- Message announced to a11y users when they selected one resolution [CHAR LIMIT=NONE] -->

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

@@ -17,7 +17,9 @@
 package com.android.settings.display;
 
 import android.content.Context;
+import android.graphics.Point;
 import android.hardware.display.DisplayManager;
+import android.util.Log;
 import android.view.Display;
 
 import androidx.annotation.VisibleForTesting;
@@ -25,32 +27,63 @@ import androidx.annotation.VisibleForTesting;
 import com.android.settings.R;
 import com.android.settings.core.BasePreferenceController;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
 /** Controller that switch the screen resolution. */
 public class ScreenResolutionController extends BasePreferenceController {
-
+    private static final String TAG = "ScreenResolutionController";
-    static final int FHD_WIDTH = 1080;
+    static final int HIGHRESOLUTION_IDX = 0;
-    static final int QHD_WIDTH = 1440;
+    static final int FULLRESOLUTION_IDX = 1;
 
     private Display mDisplay;
+    private Set<Point> mSupportedResolutions = null;
+    private int mHighWidth = 0;
+    private int mFullWidth = 0;
+    private int mHighHeight = 0;
+    private int mFullHeight = 0;
 
     public ScreenResolutionController(Context context, String key) {
         super(context, key);
 
         mDisplay =
                 mContext.getSystemService(DisplayManager.class).getDisplay(Display.DEFAULT_DISPLAY);
+
+        initSupportedResolutionData();
     }
 
-    /** Check if the width is supported by the display. */
+    /**
-    private boolean isSupportedMode(int width) {
+     * Initialize the resolution data. So far, we support two resolution switching. Save the width
+     * and the height for high resolution and full resolution.
+     */
+    private void initSupportedResolutionData() {
+        // Collect and filter the resolutions
+        Set<Point> resolutions = new HashSet<>();
         for (Display.Mode mode : getSupportedModes()) {
-            if (mode.getPhysicalWidth() == width) return true;
+            resolutions.add(new Point(mode.getPhysicalWidth(), mode.getPhysicalHeight()));
         }
-        return false;
+        mSupportedResolutions = resolutions;
+
+        // Get the width and height for high resolution and full resolution
+        List<Point> resolutionList = new ArrayList<>(resolutions);
+        if (resolutionList == null || resolutionList.size() != 2) {
+            Log.e(TAG, "No support");
+            return;
+        }
+
+        Collections.sort(resolutionList, (p1, p2) -> p1.x * p1.y - p2.x * p2.y);
+        mHighWidth = resolutionList.get(HIGHRESOLUTION_IDX).x;
+        mHighHeight = resolutionList.get(HIGHRESOLUTION_IDX).y;
+        mFullWidth = resolutionList.get(FULLRESOLUTION_IDX).x;
+        mFullHeight = resolutionList.get(FULLRESOLUTION_IDX).y;
     }
 
     /** Return true if the device contains two (or more) resolutions. */
     protected boolean checkSupportedResolutions() {
-        return isSupportedMode(FHD_WIDTH) && isSupportedMode(QHD_WIDTH);
+        return getHighWidth() != 0 && getFullWidth() != 0;
     }
 
     @Override
@@ -61,20 +94,43 @@ public class ScreenResolutionController extends BasePreferenceController {
     @Override
     public CharSequence getSummary() {
         String summary = null;
-        switch (getDisplayWidth()) {
+        int width = getDisplayWidth();
-            case FHD_WIDTH:
+        if (width == mHighWidth) {
-                summary = mContext.getString(R.string.screen_resolution_summary_high);
+            summary = mContext.getString(R.string.screen_resolution_option_high);
-                break;
+        } else if (width == mFullWidth) {
-            case QHD_WIDTH:
+            summary = mContext.getString(R.string.screen_resolution_option_full);
-                summary = mContext.getString(R.string.screen_resolution_summary_highest);
+        } else {
-                break;
+            summary = mContext.getString(R.string.screen_resolution_title);
-            default:
-                summary = mContext.getString(R.string.screen_resolution_title);
         }
 
         return summary;
     }
 
+    /** Return all supported resolutions of the device. */
+    public Set<Point> getAllSupportedResolutions() {
+        return this.mSupportedResolutions;
+    }
+
+    /** Return the high resolution width of the device. */
+    public int getHighWidth() {
+        return this.mHighWidth;
+    }
+
+    /** Return the full resolution width of the device. */
+    public int getFullWidth() {
+        return this.mFullWidth;
+    }
+
+    /** Return the high resolution height of the device. */
+    public int getHighHeight() {
+        return this.mHighHeight;
+    }
+
+    /** Return the full resolution height of the device. */
+    public int getFullHeight() {
+        return this.mFullHeight;
+    }
+
     @VisibleForTesting
     public int getDisplayWidth() {
         return mDisplay.getMode().getPhysicalWidth();

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

@@ -16,9 +16,6 @@
 
 package com.android.settings.display;
 
-import static com.android.settings.display.ScreenResolutionController.FHD_WIDTH;
-import static com.android.settings.display.ScreenResolutionController.QHD_WIDTH;
-
 import android.annotation.Nullable;
 import android.app.settings.SettingsEnums;
 import android.content.Context;
@@ -48,7 +45,6 @@ import com.android.settingslib.widget.IllustrationPreference;
 import com.android.settingslib.widget.SelectorWithWidgetPreference;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -59,8 +55,6 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
     private static final String TAG = "ScreenResolution";
 
     private Resources mResources;
-    private static final int FHD_INDEX = 0;
-    private static final int QHD_INDEX = 1;
     private static final String SCREEN_RESOLUTION = "user_selected_resolution";
     private Display mDefaultDisplay;
     private String[] mScreenResolutionOptions;
@@ -71,6 +65,9 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
     private DisplayObserver mDisplayObserver;
     private AccessibilityManager mAccessibilityManager;
 
+    private int mHighWidth;
+    private int mFullWidth;
+
     @Override
     public void onAttach(Context context) {
         super.onAttach(context);
@@ -81,11 +78,18 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
         mResources = context.getResources();
         mScreenResolutionOptions =
                 mResources.getStringArray(R.array.config_screen_resolution_options_strings);
-        mScreenResolutionSummaries =
-                mResources.getStringArray(R.array.config_screen_resolution_summaries_strings);
-        mResolutions = getAllSupportedResolution();
         mImagePreference = new IllustrationPreference(context);
         mDisplayObserver = new DisplayObserver(context);
+        ScreenResolutionController mController =
+                new ScreenResolutionController(context, "fragment");
+        mResolutions = mController.getAllSupportedResolutions();
+        mHighWidth = mController.getHighWidth();
+        mFullWidth = mController.getFullWidth();
+        mScreenResolutionSummaries =
+                new String[] {
+                    mHighWidth + " x " + mController.getHighHeight(),
+                    mFullWidth + " x " + mController.getFullHeight()
+                };
     }
 
     @Override
@@ -133,16 +137,6 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
         return candidates;
     }
 
-    /** Get all supported resolutions on the device. */
-    private Set<Point> getAllSupportedResolution() {
-        Set<Point> resolutions = new HashSet<>();
-        for (Display.Mode mode : mDefaultDisplay.getSupportedModes()) {
-            resolutions.add(new Point(mode.getPhysicalWidth(), mode.getPhysicalHeight()));
-        }
-
-        return resolutions;
-    }
-
     /** Get prefer display mode. */
     private Display.Mode getPreferMode(int width) {
         for (Point resolution : mResolutions) {
@@ -177,6 +171,7 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
 
         try {
             /** Apply the resolution change. */
+            Log.i(TAG, "setUserPreferredDisplayMode: " + mode);
             mDefaultDisplay.setUserPreferredDisplayMode(mode);
         } catch (Exception e) {
             Log.e(TAG, "setUserPreferredDisplayMode() failed", e);
@@ -194,16 +189,19 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
     /** Get the key corresponding to the resolution. */
     @VisibleForTesting
     String getKeyForResolution(int width) {
-        return width == FHD_WIDTH
+        return width == mHighWidth
-                ? mScreenResolutionOptions[FHD_INDEX]
+                ? mScreenResolutionOptions[ScreenResolutionController.HIGHRESOLUTION_IDX]
-                : width == QHD_WIDTH ? mScreenResolutionOptions[QHD_INDEX] : null;
+                : width == mFullWidth
+                        ? mScreenResolutionOptions[ScreenResolutionController.FULLRESOLUTION_IDX]
+                        : null;
     }
 
     /** Get the width corresponding to the resolution key. */
     int getWidthForResoluitonKey(String key) {
-        return mScreenResolutionOptions[FHD_INDEX].equals(key)
+        return mScreenResolutionOptions[ScreenResolutionController.HIGHRESOLUTION_IDX].equals(key)
-                ? FHD_WIDTH
+                ? mHighWidth
-                : mScreenResolutionOptions[QHD_INDEX].equals(key) ? QHD_WIDTH : -1;
+                : mScreenResolutionOptions[ScreenResolutionController.FULLRESOLUTION_IDX].equals(
+                    key) ? mFullWidth : -1;
     }
 
     @Override
@@ -248,9 +246,11 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
     private void updateIllustrationImage(IllustrationPreference preference) {
         String key = getDefaultKey();
 
-        if (TextUtils.equals(mScreenResolutionOptions[FHD_INDEX], key)) {
+        if (TextUtils.equals(
+                mScreenResolutionOptions[ScreenResolutionController.HIGHRESOLUTION_IDX], key)) {
             preference.setLottieAnimationResId(R.drawable.screen_resolution_1080p);
-        } else if (TextUtils.equals(mScreenResolutionOptions[QHD_INDEX], key)) {
+        } else if (TextUtils.equals(
+                mScreenResolutionOptions[ScreenResolutionController.FULLRESOLUTION_IDX], key)) {
             preference.setLottieAnimationResId(R.drawable.screen_resolution_1440p);
         }
     }
@@ -407,6 +407,8 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
                 return false;
             }
 
+            Log.i(TAG,
+                    "resolution changed from " + mPreviousWidth.get() + " to " + getCurrentWidth());
             return true;
         }
     }