PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[RRS] show resolution option on Settings page.

Browse Source 
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
      atest SettingsUnitTests:ScreenResolutionControllerTest
      atest SettingsUnitTests:ScreenResolutionFragmentTest
Change-Id: Ie22df7dff6e31a7697c128eabe69dfe4bba29746
This commit is contained in:
Amy Hsu
2022-11-30 16:29:04 +00:00
parent c54584127b
commit be19785b51
6 changed files with 142 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
res/values/config.xml
View File

@@ -578,13 +578,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>
</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>
<item>@string/screen_resolution_option_full</item>
</string-array>
<!-- Whether to aggregate for network selection list-->

10
res/values/strings.xml
View File

@@ -2201,14 +2201,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] -->
<string name="screen_resolution_option_highest">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>
<!-- Display settings screen, screen resolution option for full resolution [CHAR LIMIT=45] -->
<string name="screen_resolution_option_full">Full resolution</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] -->

90
src/com/android/settings/display/ScreenResolutionController.java
View File

@@ -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 {
static final int FHD_WIDTH = 1080;
static final int QHD_WIDTH = 1440;
private static final String TAG = "ScreenResolutionController";
static final int HIGHRESOLUTION_IDX = 0;
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()) {
case FHD_WIDTH:
summary = mContext.getString(R.string.screen_resolution_summary_high);
break;
case QHD_WIDTH:
summary = mContext.getString(R.string.screen_resolution_summary_highest);
break;
default:
summary = mContext.getString(R.string.screen_resolution_title);
int width = getDisplayWidth();
if (width == mHighWidth) {
summary = mContext.getString(R.string.screen_resolution_option_high);
} else if (width == mFullWidth) {
summary = mContext.getString(R.string.screen_resolution_option_full);
} else {
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();

61
src/com/android/settings/display/ScreenResolutionFragment.java
View File

@@ -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,9 +55,8 @@ 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 static final String SCREEN_RESOLUTION_KEY = "screen_resolution";
private Display mDefaultDisplay;
private String[] mScreenResolutionOptions;
private Set<Point> mResolutions;
@@ -71,6 +66,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 +79,19 @@ 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 controller =
new ScreenResolutionController(context, SCREEN_RESOLUTION_KEY);
mResolutions = controller.getAllSupportedResolutions();
mHighWidth = controller.getHighWidth();
mFullWidth = controller.getFullWidth();
Log.i(TAG, "mHighWidth:" + mHighWidth + "mFullWidth:" + mFullWidth);
mScreenResolutionSummaries =
new String[] {
mHighWidth + " x " + controller.getHighHeight(),
mFullWidth + " x " + controller.getFullHeight()
};
}
@Override
@@ -133,16 +139,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 +173,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 +191,20 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
/** Get the key corresponding to the resolution. */
@VisibleForTesting
String getKeyForResolution(int width) {
return width == FHD_WIDTH
? mScreenResolutionOptions[FHD_INDEX]
: width == QHD_WIDTH ? mScreenResolutionOptions[QHD_INDEX] : null;
return width == mHighWidth
? mScreenResolutionOptions[ScreenResolutionController.HIGHRESOLUTION_IDX]
: 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)
? FHD_WIDTH
: mScreenResolutionOptions[QHD_INDEX].equals(key) ? QHD_WIDTH : -1;
return mScreenResolutionOptions[ScreenResolutionController.HIGHRESOLUTION_IDX].equals(key)
? mHighWidth
: mScreenResolutionOptions[ScreenResolutionController.FULLRESOLUTION_IDX].equals(
key)
? mFullWidth : -1;
}
@Override
@@ -248,9 +249,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);
}
}
@@ -300,7 +303,7 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
@Override
protected boolean isPageSearchEnabled(Context context) {
ScreenResolutionController mController =
new ScreenResolutionController(context, "fragment");
new ScreenResolutionController(context, SCREEN_RESOLUTION_KEY);
return mController.checkSupportedResolutions();
}
};
@@ -408,6 +411,8 @@ public class ScreenResolutionFragment extends RadioButtonPickerFragment {
return false;
}
Log.i(TAG,
"resolution changed from " + mPreviousWidth.get() + " to " + getCurrentWidth());
return true;
}
}

29
tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java
View File

@@ -35,22 +35,23 @@ import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
public class ScreenResolutionControllerTest {
private static final int FHD_WIDTH = 1080;
private static final int QHD_WIDTH = 1440;
private ScreenResolutionController mController;
private int mHighWidth;
private int mFullWidth;
@Before
public void setUp() {
Context context = spy(ApplicationProvider.getApplicationContext());
mController = spy(new ScreenResolutionController(context, "test"));
mHighWidth = mController.getHighWidth();
mFullWidth = mController.getFullWidth();
}
@Test
public void getAvailabilityStatus_hasFhdAndQhdModes_returnAvailable() {
Display.Mode modeA = new Display.Mode(0, FHD_WIDTH, 0, 0);
Display.Mode modeB = new Display.Mode(0, QHD_WIDTH, 0, 0);
Display.Mode modeA = new Display.Mode(0, mHighWidth, 0, 0);
Display.Mode modeB = new Display.Mode(0, mFullWidth, 0, 0);
Display.Mode[] modes = {modeA, modeB};
doReturn(modes).when(mController).getSupportedModes();
@@ -60,27 +61,25 @@ public class ScreenResolutionControllerTest {
@Test
public void getAvailabilityStatus_hasOneMode_returnUnsupported() {
Display.Mode modeA = new Display.Mode(0, FHD_WIDTH, 0, 0);
Display.Mode[] modes = {modeA};
doReturn(modes).when(mController).getSupportedModes();
doReturn(0).when(mController).getHighWidth();
assertThat(mController.getAvailabilityStatus())
.isEqualTo(BasePreferenceController.UNSUPPORTED_ON_DEVICE);
}
@Test
public void updateState_screenResolutionFHD_shouldSetSummaryToFHD() {
int width = FHD_WIDTH;
public void updateState_HighResolution_shouldSetSummaryToHighResolution() {
int width = mHighWidth;
doReturn(width).when(mController).getDisplayWidth();
assertThat(mController.getSummary().toString()).isEqualTo("1080p FHD+");
assertThat(mController.getSummary().toString()).isEqualTo("High resolution");
}
@Test
public void updateState_screenResolutionQHD_shouldSetSummaryToQHD() {
int width = QHD_WIDTH;
public void updateState_FullResolution_shouldSetSummaryToFullResolution() {
int width = mFullWidth;
doReturn(width).when(mController).getDisplayWidth();
assertThat(mController.getSummary().toString()).isEqualTo("1440p QHD+");
assertThat(mController.getSummary().toString()).isEqualTo("Full resolution");
}
}

33
tests/unit/src/com/android/settings/display/ScreenResolutionFragmentTest.java
View File

@@ -37,59 +37,62 @@ public class ScreenResolutionFragmentTest {
private Context mContext;
private ScreenResolutionFragment mFragment;
private static final int FHD_WIDTH = 1080;
private static final int QHD_WIDTH = 1440;
private ScreenResolutionController mController;
private int mHighWidth;
private int mFullWidth;
@Before
@UiThreadTest
public void setup() {
mContext = spy(ApplicationProvider.getApplicationContext());
mFragment = spy(new ScreenResolutionFragment());
mController = spy(new ScreenResolutionController(mContext, "test"));
mHighWidth = mController.getHighWidth();
mFullWidth = mController.getFullWidth();
}
@Test
@UiThreadTest
public void getDefaultKey_FHD() {
Display.Mode mode = new Display.Mode(0, FHD_WIDTH, 0, 0);
public void getDefaultKey_highResolution() {
Display.Mode mode = new Display.Mode(0, mHighWidth, 0, 0);
doReturn(mode).when(mFragment).getDisplayMode();
doReturn(mContext).when(mFragment).getContext();
mFragment.onAttach(mContext);
assertThat(mFragment.getDefaultKey()).isEqualTo(mFragment.getKeyForResolution(FHD_WIDTH));
assertThat(mFragment.getDefaultKey()).isEqualTo(mFragment.getKeyForResolution(mHighWidth));
}
@Test
@UiThreadTest
public void getDefaultKey_QHD() {
Display.Mode mode = new Display.Mode(0, QHD_WIDTH, 0, 0);
public void getDefaultKey_fullResolution() {
Display.Mode mode = new Display.Mode(0, mFullWidth, 0, 0);
doReturn(mode).when(mFragment).getDisplayMode();
doReturn(mContext).when(mFragment).getContext();
mFragment.onAttach(mContext);
assertThat(mFragment.getDefaultKey()).isEqualTo(mFragment.getKeyForResolution(QHD_WIDTH));
assertThat(mFragment.getDefaultKey()).isEqualTo(mFragment.getKeyForResolution(mFullWidth));
}
@Test
@UiThreadTest
public void setDefaultKey_FHD() {
public void setDefaultKey_highResolution() {
doReturn(mContext).when(mFragment).getContext();
mFragment.onAttach(mContext);
mFragment.setDefaultKey(mFragment.getKeyForResolution(FHD_WIDTH));
mFragment.setDefaultKey(mFragment.getKeyForResolution(mHighWidth));
verify(mFragment).setDisplayMode(FHD_WIDTH);
verify(mFragment).setDisplayMode(mHighWidth);
}
@Test
@UiThreadTest
public void setDefaultKey_QHD() {
public void setDefaultKey_fullResolution() {
doReturn(mContext).when(mFragment).getContext();
mFragment.onAttach(mContext);
mFragment.setDefaultKey(mFragment.getKeyForResolution(QHD_WIDTH));
mFragment.setDefaultKey(mFragment.getKeyForResolution(mFullWidth));
verify(mFragment).setDisplayMode(QHD_WIDTH);
verify(mFragment).setDisplayMode(mFullWidth);
}
@Test