feat(brightness suw): hide brightness preferences if restricted

By default if a RestrictedPreference is restricted then the preference
becomes disabled but still visible. But for brightness preferences in
A11y SUW we'd like to hide them if they're restricted and disabled,
since it's meaningless to show disabled items in SUW.

To achieve this, in PreferenceController#displayPreference we check the
whether the preference is RestrictedPreference and restricted, so we can
decide whether to hide it. Besides, if the preference is restricted and
we hide it, in PreferenceController#getAvailableStatis we also return
CONDITIONALLY_UNAVAILABLE to make consistency.

Bug: 384620216
Flag: com.android.settings.accessibility.add_brightness_settings_in_suw
Test: manually
      atest AutoBrightnessPreferenceControllerForSetupWizardTest
      atest BrightnessLevelPreferenceControllerForSetupWizardTest
Change-Id: Ifb68b4d64fc111d91a23457882a006002173d232

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

@@ -19,8 +19,12 @@ package com.android.settings.display;
 import android.content.Context;
 
 import androidx.annotation.NonNull;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
 
 import com.android.settings.accessibility.Flags;
+import com.android.settingslib.RestrictedPreferenceHelper;
+import com.android.settingslib.RestrictedPreferenceHelperProvider;
 
 /**
  * The top-level preference controller that updates the adaptive brightness in the SetupWizard.
@@ -28,15 +32,35 @@ import com.android.settings.accessibility.Flags;
 public class AutoBrightnessPreferenceControllerForSetupWizard
         extends AutoBrightnessPreferenceController {
 
+    private RestrictedPreferenceHelper mRestrictedPreferenceHelper;
+
     public AutoBrightnessPreferenceControllerForSetupWizard(@NonNull Context context,
             @NonNull String key) {
         super(context, key);
     }
 
+    private boolean isRestricted() {
+        if (mRestrictedPreferenceHelper == null) {
+            return false;
+        }
+        return mRestrictedPreferenceHelper.isDisabledByAdmin()
+                || mRestrictedPreferenceHelper.isDisabledByEcm();
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        Preference preference = screen.findPreference(getPreferenceKey());
+        if (preference instanceof RestrictedPreferenceHelperProvider helperProvider) {
+            mRestrictedPreferenceHelper = helperProvider.getRestrictedPreferenceHelper();
+            preference.setVisible(!isRestricted());
+        }
+    }
+
     @Override
     @AvailabilityStatus
     public int getAvailabilityStatus() {
-        if (!Flags.addBrightnessSettingsInSuw()) {
+        if (!Flags.addBrightnessSettingsInSuw() || isRestricted()) {
             return CONDITIONALLY_UNAVAILABLE;
         }
         return super.getAvailabilityStatus();

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

@@ -20,8 +20,12 @@ import android.content.Context;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
 
 import com.android.settings.accessibility.Flags;
+import com.android.settingslib.RestrictedPreferenceHelper;
+import com.android.settingslib.RestrictedPreferenceHelperProvider;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 /**
@@ -31,15 +35,35 @@ import com.android.settingslib.core.lifecycle.Lifecycle;
 public class BrightnessLevelPreferenceControllerForSetupWizard extends
         BrightnessLevelPreferenceController {
 
+    private RestrictedPreferenceHelper mRestrictedPreferenceHelper;
+
     public BrightnessLevelPreferenceControllerForSetupWizard(@NonNull Context context,
             @Nullable Lifecycle lifecycle) {
         super(context, lifecycle);
     }
 
+    private boolean isRestricted() {
+        if (mRestrictedPreferenceHelper == null) {
+            return false;
+        }
+        return mRestrictedPreferenceHelper.isDisabledByAdmin()
+                || mRestrictedPreferenceHelper.isDisabledByEcm();
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        Preference preference = screen.findPreference(getPreferenceKey());
+        if (preference instanceof RestrictedPreferenceHelperProvider helperProvider) {
+            mRestrictedPreferenceHelper = helperProvider.getRestrictedPreferenceHelper();
+            preference.setVisible(!isRestricted());
+        }
+    }
+
     @Override
     @AvailabilityStatus
     public int getAvailabilityStatus() {
-        if (!Flags.addBrightnessSettingsInSuw()) {
+        if (!Flags.addBrightnessSettingsInSuw() || isRestricted()) {
             return CONDITIONALLY_UNAVAILABLE;
         }
         return super.getAvailabilityStatus();

tests/robotests/src/com/android/settings/display/AutoBrightnessPreferenceControllerForSetupWizardTest.java

@@ -16,19 +16,28 @@
 
 package com.android.settings.display;
 
+
 import static com.android.settings.core.BasePreferenceController.AVAILABLE_UNSEARCHABLE;
 import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
 import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_DEVICE;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.mock;
+
 import android.content.Context;
 import android.platform.test.annotations.DisableFlags;
 import android.platform.test.annotations.EnableFlags;
 import android.platform.test.flag.junit.SetFlagsRule;
 
+import androidx.preference.Preference;
+import androidx.preference.PreferenceManager;
+import androidx.preference.PreferenceScreen;
+
 import com.android.settings.accessibility.Flags;
 import com.android.settings.testutils.shadow.SettingsShadowResources;
+import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.RestrictedSwitchPreference;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -58,35 +67,79 @@ public class AutoBrightnessPreferenceControllerForSetupWizardTest {
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = RuntimeEnvironment.application;
+
         mController =
                 new AutoBrightnessPreferenceControllerForSetupWizard(mContext, PREFERENCE_KEY);
     }
 
     @Test
     @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
-    public void getAvailabilityStatus_configTrueAndFlagOn_shouldReturnAvailableUnsearchable() {
+    public void displayPreference_flagOn_preferenceVisibleTrue() {
-        SettingsShadowResources.overrideResource(
+        Preference preference =
-                com.android.internal.R.bool.config_automatic_brightness_available, true);
+                displayPreference(/* configAvailable= */ true, /* restricted= */ false);
+        assertThat(preference.isVisible()).isTrue();
+    }
 
+    @Test
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void displayPreference_flagOnAndRestricted_preferenceVisibleFalse() {
+        Preference preference =
+                displayPreference(/* configAvailable= */ true, /* restricted= */ true);
+        assertThat(preference.isVisible()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void getAvailabilityStatus_configTrueAndFlagOn_availableUnsearchable() {
+        displayPreference(/* configAvailable= */ true, /* restricted= */ false);
         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE_UNSEARCHABLE);
     }
 
     @Test
     @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
-    public void getAvailabilityStatus_configFalseSetAndFlagOn_shouldReturnUnsupportedOnDevice() {
+    public void getAvailabilityStatus_configTrueAndFlagOnAndRestricted_conditionallyUnavailable() {
-        SettingsShadowResources.overrideResource(
+        displayPreference(/* configAvailable= */ true, /* restricted= */ true);
-                com.android.internal.R.bool.config_automatic_brightness_available, false);
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+    }
 
+    @Test
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void getAvailabilityStatus_configFalseAndFlagOn_unsupportedOnDevice() {
+        displayPreference(/* configAvailable= */ false, /* restricted= */ false);
         assertThat(mController.getAvailabilityStatus()).isEqualTo(UNSUPPORTED_ON_DEVICE);
     }
 
     @Test
-    @DisableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
-    public void getAvailabilityStatus_flagOff_shouldReturnConditionallyUnavailable() {
+    public void getAvailabilityStatus_configFalseAndFlagOnAndRestricted_conditionallyUnavailable() {
-        SettingsShadowResources.overrideResource(
+        displayPreference(/* configAvailable= */ false, /* restricted= */ true);
-                com.android.internal.R.bool.config_automatic_brightness_available, true);
-
         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
     }
+
+    @Test
+    @DisableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void getAvailabilityStatus_flagOff_conditionallyUnavailable() {
+        displayPreference(/* configAvailable= */ true, /* restricted= */ false);
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+    }
+
+    private RestrictedSwitchPreference displayPreference(
+            boolean configAvailable, boolean restricted) {
+        SettingsShadowResources.overrideResource(
+                com.android.internal.R.bool.config_automatic_brightness_available, configAvailable);
+
+        final PreferenceManager manager = new PreferenceManager(mContext);
+        final PreferenceScreen screen = manager.createPreferenceScreen(mContext);
+        final RestrictedSwitchPreference preference = new RestrictedSwitchPreference(mContext);
+        preference.setKey(mController.getPreferenceKey());
+        preference.setDisabledByAdmin(restricted
+                ? mock(RestrictedLockUtils.EnforcedAdmin.class)
+                : null);
+        assertThat(preference.isDisabledByAdmin()).isEqualTo(restricted);
+        screen.addPreference(preference);
+
+        mController.displayPreference(screen);
+        return preference;
+    }
 }
 

tests/robotests/src/com/android/settings/display/BrightnessLevelPreferenceControllerForSetupWizardTest.java

@@ -21,12 +21,20 @@ import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_U
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.mock;
+
 import android.content.Context;
 import android.platform.test.annotations.DisableFlags;
 import android.platform.test.annotations.EnableFlags;
 import android.platform.test.flag.junit.SetFlagsRule;
 
+import androidx.preference.Preference;
+import androidx.preference.PreferenceManager;
+import androidx.preference.PreferenceScreen;
+
 import com.android.settings.accessibility.Flags;
+import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.RestrictedPreference;
 
 import org.junit.Before;
 import org.junit.Rule;
@@ -51,19 +59,58 @@ public class BrightnessLevelPreferenceControllerForSetupWizardTest {
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = RuntimeEnvironment.application;
+
         mController = new BrightnessLevelPreferenceControllerForSetupWizard(mContext,
                 /* lifecycle= */ null);
     }
 
     @Test
     @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
-    public void getAvailabilityStatus_flagOn_shouldReturnAvailable() {
+    public void displayPreference_flagOn_preferenceVisibleTrue() {
+        Preference preference = displayPreference(/* restricted= */ false);
+        assertThat(preference.isVisible()).isTrue();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void displayPreference_flagOnAndRestricted_preferenceVisibleFalse() {
+        Preference preference = displayPreference(/* restricted= */ true);
+        assertThat(preference.isVisible()).isFalse();
+    }
+
+    @Test
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void getAvailabilityStatus_flagOn_available() {
+        displayPreference(/* restricted= */ false);
         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
     }
 
     @Test
-    @DisableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    @EnableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
-    public void getAvailabilityStatus_flagOff_shouldReturnConditionallyUnavailable() {
+    public void getAvailabilityStatus_flagOnAndRestricted_conditionallyUnavailable() {
+        displayPreference(/* restricted= */ true);
         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
     }
+
+    @Test
+    @DisableFlags(Flags.FLAG_ADD_BRIGHTNESS_SETTINGS_IN_SUW)
+    public void getAvailabilityStatus_flagOff_conditionallyUnavailable() {
+        displayPreference(/* restricted= */ false);
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+    }
+
+    private RestrictedPreference displayPreference(boolean restricted) {
+        final PreferenceManager manager = new PreferenceManager(mContext);
+        final PreferenceScreen screen = manager.createPreferenceScreen(mContext);
+        final RestrictedPreference preference = new RestrictedPreference(mContext);
+        preference.setKey(mController.getPreferenceKey());
+        preference.setDisabledByAdmin(restricted
+                ? mock(RestrictedLockUtils.EnforcedAdmin.class)
+                : null);
+        assertThat(preference.isDisabledByAdmin()).isEqualTo(restricted);
+        screen.addPreference(preference);
+
+        mController.displayPreference(screen);
+        return preference;
+    }
 }