From 0183cfd81642626aaa2c9e0d8592f0382ccd1a33 Mon Sep 17 00:00:00 2001 From: Yuxin Hu Date: Sat, 20 May 2023 00:52:11 +0000 Subject: [PATCH] Fix "Enable ANGLE" switch behavior when Developer Option Switch is off Fix below bugs: 1) When developer option switch is turned off, "Enable ANGLE" switch is not disabled. Fixed it in GraphicsDriverEnableAngleAsSystemDriverController::update(). 2) When user turns off developer option switch, a restart is not always mandatory. However, we should ask user to restart the device is "Enable ANGLE" is forced to change due to developer option switch turning off. Fixed it in DevelopmentSettingsDashboardFragment::onSwitchChanged(). 3) When user turns off developer option switch and the reboot dialog pops up, user can dismiss the dialog by not clicking either POSITIVE_BUTTON or NEGATIVE_BUTTON. We should enforce user to click the button and disallow the option to dimiss the dialog by touching screen areas outside the window's bounds. Fixed it in DisableDevSettingsDialogFragment.java. Did a few clean-up and in GraphicsDriverEnableAngleAsSystemDriverController.java, and updated unit test to reflect new code behavior. Bug: b/270994705 Test: m; flash and device can boot. Test: atest -c GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest Test: atest GraphicsDriverEnableAngleAsSystemDriverControllerTest Test: atest SettingsRoboTests:FreeformWindowsPreferenceControllerTest Test: atest SettingsRoboTests:DesktopModePreferenceControllerTest Change-Id: I199b2fe59b6ad948b753793254c822a293d8b40d --- .../DevelopmentSettingsDashboardFragment.java | 7 ++- .../DisableDevSettingsDialogFragment.java | 4 ++ ...erEnableAngleAsSystemDriverController.java | 57 +++++++++++-------- ...ableAngleAsSystemDriverControllerTest.java | 3 + ...ngleAsSystemDriverControllerJUnitTest.java | 26 +++------ 5 files changed, 55 insertions(+), 42 deletions(-) diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java index 87d8c17e307..f7be1aa47b1 100644 --- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java +++ b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java @@ -354,13 +354,18 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra final NfcVerboseVendorLogPreferenceController nfcVerboseLogController = getDevelopmentOptionsController( NfcVerboseVendorLogPreferenceController.class); + final GraphicsDriverEnableAngleAsSystemDriverController enableAngleController = + getDevelopmentOptionsController( + GraphicsDriverEnableAngleAsSystemDriverController.class); // If hardware offload isn't default value, we must reboot after disable // developer options. Show a dialog for the user to confirm. if ((a2dpController == null || a2dpController.isDefaultValue()) && (leAudioController == null || leAudioController.isDefaultValue()) && (nfcSnoopLogController == null || nfcSnoopLogController.isDefaultValue()) && (nfcVerboseLogController == null - || nfcVerboseLogController.isDefaultValue())) { + || nfcVerboseLogController.isDefaultValue()) + && (enableAngleController == null + || enableAngleController.isDefaultValue())) { disableDeveloperOptions(); } else { DisableDevSettingsDialogFragment.show(this /* host */); diff --git a/src/com/android/settings/development/DisableDevSettingsDialogFragment.java b/src/com/android/settings/development/DisableDevSettingsDialogFragment.java index 5db2ed4281b..224768b0561 100644 --- a/src/com/android/settings/development/DisableDevSettingsDialogFragment.java +++ b/src/com/android/settings/development/DisableDevSettingsDialogFragment.java @@ -45,6 +45,10 @@ public class DisableDevSettingsDialogFragment extends InstrumentedDialogFragment public static void show(DevelopmentSettingsDashboardFragment host) { final DisableDevSettingsDialogFragment dialog = new DisableDevSettingsDialogFragment(); dialog.setTargetFragment(host, 0 /* requestCode */); + // We need to handle data changes and switch state based on which button user clicks, + // therefore we should enforce user to click one of the buttons + // by disallowing dialog dismiss through tapping outside of dialog bounds. + dialog.setCancelable(false); final FragmentManager manager = host.getActivity().getSupportFragmentManager(); dialog.show(manager, TAG); } diff --git a/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverController.java b/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverController.java index 1a065a96aaa..b3af95ec0cc 100644 --- a/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverController.java +++ b/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverController.java @@ -81,6 +81,11 @@ public class GraphicsDriverEnableAngleAsSystemDriverController this(context, fragment, new Injector()); } + private boolean isAngleSupported() { + return TextUtils.equals( + mSystemProperties.get(PROPERTY_RO_GFX_ANGLE_SUPPORTED, ""), "true"); + } + @VisibleForTesting GraphicsDriverEnableAngleAsSystemDriverController( Context context, DevelopmentSettingsDashboardFragment fragment, Injector injector) { @@ -118,38 +123,44 @@ public class GraphicsDriverEnableAngleAsSystemDriverController this); } - @Override - public void updateState(Preference preference) { - // set switch on if "persist.graphics.egl" is "angle" and angle is built in /vendor - // set switch off otherwise. + /** Return the default value of "persist.graphics.egl" */ + public boolean isDefaultValue() { + if (!isAngleSupported()) { + return true; + } + final String currentGlesDriver = mSystemProperties.get(PROPERTY_PERSISTENT_GRAPHICS_EGL, ""); - final boolean isAngle = TextUtils.equals(ANGLE_DRIVER_SUFFIX, currentGlesDriver); - final boolean isAngleSupported = - TextUtils.equals( - mSystemProperties.get(PROPERTY_RO_GFX_ANGLE_SUPPORTED, ""), "true"); - ((SwitchPreference) mPreference).setChecked(isAngle && isAngleSupported); - ((SwitchPreference) mPreference).setEnabled(isAngleSupported); + // default value of "persist.graphics.egl" is "" + return TextUtils.isEmpty(currentGlesDriver); } @Override - protected void onDeveloperOptionsSwitchEnabled() { - // only enable the switch if ro.gfx.angle.supported is true - // we use ro.gfx.angle.supported to indicate if ANGLE libs are installed under /vendor - final boolean isAngleSupported = - TextUtils.equals( - mSystemProperties.get(PROPERTY_RO_GFX_ANGLE_SUPPORTED, ""), "true"); - ((SwitchPreference) mPreference).setEnabled(isAngleSupported); + public void updateState(Preference preference) { + super.updateState(preference); + if (isAngleSupported()) { + // set switch on if "persist.graphics.egl" is "angle" and angle is built in /vendor + // set switch off otherwise. + final String currentGlesDriver = + mSystemProperties.get(PROPERTY_PERSISTENT_GRAPHICS_EGL, ""); + final boolean isAngle = TextUtils.equals(ANGLE_DRIVER_SUFFIX, currentGlesDriver); + ((SwitchPreference) mPreference).setChecked(isAngle); + } else { + mPreference.setEnabled(false); + ((SwitchPreference) mPreference).setChecked(false); + } } @Override protected void onDeveloperOptionsSwitchDisabled() { - // 1) set the persist.graphics.egl empty string - GraphicsEnvironment.getInstance().toggleAngleAsSystemDriver(false); - // 2) reset the switch - ((SwitchPreference) mPreference).setChecked(false); - // 3) disable switch - ((SwitchPreference) mPreference).setEnabled(false); + // 1) disable the switch + super.onDeveloperOptionsSwitchDisabled(); + if (isAngleSupported()) { + // 2) set the persist.graphics.egl empty string + GraphicsEnvironment.getInstance().toggleAngleAsSystemDriver(false); + // 3) reset the switch + ((SwitchPreference) mPreference).setChecked(false); + } } void toggleSwitchBack() { diff --git a/tests/robotests/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerTest.java b/tests/robotests/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerTest.java index de380c40c8e..9210b870d77 100644 --- a/tests/robotests/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerTest.java +++ b/tests/robotests/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerTest.java @@ -141,6 +141,7 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerTest { @Test public void onDeveloperOptionSwitchDisabled_shouldDisableAngleAsSystemDriver() { + ShadowSystemProperties.override(PROPERTY_RO_GFX_ANGLE_SUPPORTED, "true"); mController.onDeveloperOptionsSwitchDisabled(); final String systemEGLDriver = SystemProperties.get(PROPERTY_PERSISTENT_GRAPHICS_EGL); assertThat(systemEGLDriver).isEqualTo(""); @@ -148,12 +149,14 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerTest { @Test public void onDeveloperOptionSwitchDisabled_preferenceShouldNotBeChecked() { + ShadowSystemProperties.override(PROPERTY_RO_GFX_ANGLE_SUPPORTED, "true"); mController.onDeveloperOptionsSwitchDisabled(); verify(mPreference).setChecked(false); } @Test public void onDeveloperOptionsSwitchDisabled_preferenceShouldNotBeEnabled() { + ShadowSystemProperties.override(PROPERTY_RO_GFX_ANGLE_SUPPORTED, "true"); mController.onDeveloperOptionsSwitchDisabled(); verify(mPreference).setEnabled(false); } diff --git a/tests/unit/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest.java b/tests/unit/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest.java index c23292ac54a..ae35431fef7 100644 --- a/tests/unit/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest.java +++ b/tests/unit/src/com/android/settings/development/graphicsdriver/GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest.java @@ -57,7 +57,7 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest { private GraphicsDriverEnableAngleAsSystemDriverController mController; // Signal to wait for SystemProperty values changed - private class PropertyChangeSignal { + private static class PropertyChangeSignal { private CountDownLatch mCountDownLatch; private Runnable mCountDownJob; @@ -217,23 +217,7 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest { } @Test - public void onDeveloperOptionSwitchEnabled_angleSupported_PreferenceShouldEnabled() { - when(mSystemPropertiesMock.get(eq(PROPERTY_RO_GFX_ANGLE_SUPPORTED), any())) - .thenReturn("true"); - mController.onDeveloperOptionsSwitchEnabled(); - assertThat(mPreference.isEnabled()).isTrue(); - } - - @Test - public void onDeveloperOptionSwitchEnabled_angleNotSupported_PrefenceShouldDisabled() { - when(mSystemPropertiesMock.get(eq(PROPERTY_RO_GFX_ANGLE_SUPPORTED), any())) - .thenReturn("false"); - mController.onDeveloperOptionsSwitchEnabled(); - assertThat(mPreference.isEnabled()).isFalse(); - } - - @Test - public void onDeveloperOptionSwitchDisabled_angleIsNotSystemGLESDriver() { + public void onDeveloperOptionSwitchDisabled_angleShouldNotBeSystemGLESDriver() { // Add a callback when SystemProperty changes. // This allows the thread to wait until // GpuService::toggleAngleAsSystemDriver() updates the persist.graphics.egl. @@ -242,6 +226,8 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest { // Test that onDeveloperOptionSwitchDisabled, // persist.graphics.egl updates to "" + when(mSystemPropertiesMock.get(eq(PROPERTY_RO_GFX_ANGLE_SUPPORTED), any())) + .thenReturn("true"); mController.onDeveloperOptionsSwitchDisabled(); propertyChangeSignal1.wait(100); final String systemEGLDriver = SystemProperties.get(PROPERTY_PERSISTENT_GRAPHICS_EGL); @@ -253,12 +239,16 @@ public class GraphicsDriverEnableAngleAsSystemDriverControllerJUnitTest { @Test public void onDeveloperOptionSwitchDisabled_PreferenceShouldNotBeChecked() { + when(mSystemPropertiesMock.get(eq(PROPERTY_RO_GFX_ANGLE_SUPPORTED), any())) + .thenReturn("true"); mController.onDeveloperOptionsSwitchDisabled(); assertThat(mPreference.isChecked()).isFalse(); } @Test public void onDeveloperOptionSwitchDisabled_PreferenceShouldDisabled() { + when(mSystemPropertiesMock.get(eq(PROPERTY_RO_GFX_ANGLE_SUPPORTED), any())) + .thenReturn("true"); mController.onDeveloperOptionsSwitchDisabled(); assertThat(mPreference.isEnabled()).isFalse(); }