Merge "[RRS] show resolution option on Settings page." (2209c02d) · Commits · e / os / android_packages_apps_Settings

res/values/config.xml

+1 −7

Original line number	Diff line number	Diff line
		@@ -600,13 +600,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-->

res/values/strings.xml

+3 −7

Original line number	Diff line number	Diff line
		@@ -2210,14 +2210,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] -->

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

+73 −17

Original line number	Diff line number	Diff line
		@@ -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:
		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();

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

+33 −28

Original line number	Diff line number	Diff line
		@@ -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;
		}
		}

tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java

+14 −15

Original line number	Diff line number	Diff line
		@@ -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");
		}
		}