From 01c8438223e5b0f682a8551c8a5d72e2066ce725 Mon Sep 17 00:00:00 2001 From: Jason Chang Date: Wed, 1 Feb 2023 08:17:57 +0000 Subject: [PATCH 1/3] Fix Face and Fingerprint setting page's title "Use face or fingerprint to" is missing Add a new title string for biometrics settings page title. Bug: 264902889 Test: manually local build then using issue reproducible steps to verify Face and Fingerprint Settings page category tiile strings Change-Id: Ifeb3529e0ff444fc75b81ef9bbafc66c3de41956 --- res/values/strings.xml | 2 ++ res/xml/security_settings_combined_biometric.xml | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/res/values/strings.xml b/res/values/strings.xml index 77c40d0a4a7..3bbd493bd4b 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -839,6 +839,8 @@ When you set up Face Unlock and Fingerprint Unlock, your phone will ask for your fingerprint when you wear a mask or are in a dark area Ways to unlock + + Use face or fingerprint to Unlock your phone diff --git a/res/xml/security_settings_combined_biometric.xml b/res/xml/security_settings_combined_biometric.xml index ef3a3fd1ff2..50edce68757 100644 --- a/res/xml/security_settings_combined_biometric.xml +++ b/res/xml/security_settings_combined_biometric.xml @@ -43,7 +43,8 @@ + android:key="biometric_ways_to_use" + android:title="@string/biometric_settings_category_use_face_fingerprint"> Date: Fri, 3 Feb 2023 23:54:25 +0000 Subject: [PATCH 2/3] Fix connected wifi entry not clearing when Wifi is disabled Connected wifi entry is represented by either mConnectedWifiEntryPreferenceCategory or mFirstWifiEntryPreferenceCategory, but we only clear mConnectedWifiEntryPreferenceCategory when Wifi is disabled. Make sure to also clear mFirstWifiEntryPreferenceCategory. Bug: 267815756 Test: manually verify connected wifi is hidden when wifi is disabled Change-Id: I4c30a658200f1ab90af5ce41a6531f5784a8de5d --- .../android/settings/network/NetworkProviderSettings.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/com/android/settings/network/NetworkProviderSettings.java b/src/com/android/settings/network/NetworkProviderSettings.java index a2ade4740a1..e285a91090d 100644 --- a/src/com/android/settings/network/NetworkProviderSettings.java +++ b/src/com/android/settings/network/NetworkProviderSettings.java @@ -1098,10 +1098,13 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment .launch(); } - /** Removes all preferences and hide the {@link #mConnectedWifiEntryPreferenceCategory}. */ + /** Removes all preferences and hide the {@link #mConnectedWifiEntryPreferenceCategory} and + * {@link #mFirstWifiEntryPreferenceCategory}. */ private void removeConnectedWifiEntryPreference() { mConnectedWifiEntryPreferenceCategory.removeAll(); mConnectedWifiEntryPreferenceCategory.setVisible(false); + mFirstWifiEntryPreferenceCategory.setVisible(false); + mFirstWifiEntryPreferenceCategory.removeAll(); } private void removeWifiEntryPreference() { From be19785b51809684bbdb71b589ed118e4702dfa5 Mon Sep 17 00:00:00 2001 From: Amy Hsu Date: Wed, 30 Nov 2022 16:29:04 +0000 Subject: [PATCH 3/3] [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 atest SettingsUnitTests:ScreenResolutionControllerTest atest SettingsUnitTests:ScreenResolutionFragmentTest Change-Id: Ie22df7dff6e31a7697c128eabe69dfe4bba29746 --- res/values/config.xml | 8 +- res/values/strings.xml | 10 +-- .../display/ScreenResolutionController.java | 90 +++++++++++++++---- .../display/ScreenResolutionFragment.java | 61 +++++++------ .../ScreenResolutionControllerTest.java | 29 +++--- .../display/ScreenResolutionFragmentTest.java | 33 +++---- 6 files changed, 142 insertions(+), 89 deletions(-) diff --git a/res/values/config.xml b/res/values/config.xml index 0c610e3a6a9..db62b186f86 100755 --- a/res/values/config.xml +++ b/res/values/config.xml @@ -578,13 +578,7 @@ @string/screen_resolution_option_high - @string/screen_resolution_option_highest - - - - - @string/screen_resolution_summary_high - @string/screen_resolution_summary_highest + @string/screen_resolution_option_full diff --git a/res/values/strings.xml b/res/values/strings.xml index 77c40d0a4a7..61debdcb994 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -2201,14 +2201,10 @@ Screen resolution - + High resolution - - Full resolution - - 1080p FHD+ - - 1440p QHD+ + + Full resolution Full resolution uses more of your battery. Switching your resolution may cause some apps to restart. diff --git a/src/com/android/settings/display/ScreenResolutionController.java b/src/com/android/settings/display/ScreenResolutionController.java index dca12757e18..a3433d405a5 100644 --- a/src/com/android/settings/display/ScreenResolutionController.java +++ b/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 { - - 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 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 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 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 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(); diff --git a/src/com/android/settings/display/ScreenResolutionFragment.java b/src/com/android/settings/display/ScreenResolutionFragment.java index 13191cee189..b40b48f246f 100644 --- a/src/com/android/settings/display/ScreenResolutionFragment.java +++ b/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,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 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 getAllSupportedResolution() { - Set 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; } } diff --git a/tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java b/tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java index a32904ecb35..b5df3a24472 100644 --- a/tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java +++ b/tests/unit/src/com/android/settings/display/ScreenResolutionControllerTest.java @@ -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"); } } diff --git a/tests/unit/src/com/android/settings/display/ScreenResolutionFragmentTest.java b/tests/unit/src/com/android/settings/display/ScreenResolutionFragmentTest.java index 4e674d271cb..84095317e17 100644 --- a/tests/unit/src/com/android/settings/display/ScreenResolutionFragmentTest.java +++ b/tests/unit/src/com/android/settings/display/ScreenResolutionFragmentTest.java @@ -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