diff --git a/packages/SettingsLib/src/com/android/settingslib/RestrictedPreferenceHelper.java b/packages/SettingsLib/src/com/android/settingslib/RestrictedPreferenceHelper.java index 1ba1f72cb2e18..2dbfef0391972 100644 --- a/packages/SettingsLib/src/com/android/settingslib/RestrictedPreferenceHelper.java +++ b/packages/SettingsLib/src/com/android/settingslib/RestrictedPreferenceHelper.java @@ -141,8 +141,9 @@ public class RestrictedPreferenceHelper { /** * Disable this preference based on the enforce admin. * - * @param EnforcedAdmin Details of the admin who enforced the restriction. If it - * is {@code null}, then this preference will be enabled. Otherwise, it will be disabled. + * @param admin details of the admin who enforced the restriction. If it is + * {@code null}, then this preference will be enabled. Otherwise, it will be disabled. + * Only gray out the preference which is not {@link RestrictedTopLevelPreference}. * @return true if the disabled state was changed. */ public boolean setDisabledByAdmin(EnforcedAdmin admin) { @@ -153,7 +154,11 @@ public class RestrictedPreferenceHelper { mDisabledByAdmin = disabled; changed = true; } - mPreference.setEnabled(!disabled); + + if (!(mPreference instanceof RestrictedTopLevelPreference)) { + mPreference.setEnabled(!disabled); + } + return changed; } diff --git a/packages/SettingsLib/src/com/android/settingslib/RestrictedTopLevelPreference.java b/packages/SettingsLib/src/com/android/settingslib/RestrictedTopLevelPreference.java new file mode 100644 index 0000000000000..0096015aa875f --- /dev/null +++ b/packages/SettingsLib/src/com/android/settingslib/RestrictedTopLevelPreference.java @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settingslib; + +import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; + +import android.content.Context; +import android.os.UserHandle; +import android.util.AttributeSet; + +import androidx.core.content.res.TypedArrayUtils; +import androidx.preference.Preference; +import androidx.preference.PreferenceManager; +import androidx.preference.PreferenceViewHolder; + +/** Top level preference that can be disabled by a device admin using a user restriction. */ +public class RestrictedTopLevelPreference extends Preference { + private RestrictedPreferenceHelper mHelper; + + public RestrictedTopLevelPreference(Context context, AttributeSet attrs, + int defStyleAttr, int defStyleRes) { + super(context, attrs, defStyleAttr, defStyleRes); + mHelper = new RestrictedPreferenceHelper(context, /* preference= */ this, attrs); + } + + public RestrictedTopLevelPreference(Context context, AttributeSet attrs, int defStyleAttr) { + this(context, attrs, defStyleAttr, /* defStyleRes= */ 0); + } + + public RestrictedTopLevelPreference(Context context, AttributeSet attrs) { + this(context, attrs, TypedArrayUtils.getAttr(context, R.attr.preferenceStyle, + android.R.attr.preferenceStyle)); + } + + public RestrictedTopLevelPreference(Context context) { + this(context, /* attrs= */ null); + } + + @Override + public void onBindViewHolder(PreferenceViewHolder holder) { + super.onBindViewHolder(holder); + mHelper.onBindViewHolder(holder); + } + + @Override + public void performClick() { + if (!mHelper.performClick()) { + super.performClick(); + } + } + + @Override + protected void onAttachedToHierarchy(PreferenceManager preferenceManager) { + mHelper.onAttachedToHierarchy(); + super.onAttachedToHierarchy(preferenceManager); + } + + /** + * Set the user restriction and disable this preference. + * + * @param userRestriction constant from {@link android.os.UserManager} + */ + public void checkRestrictionAndSetDisabled(String userRestriction) { + mHelper.checkRestrictionAndSetDisabled(userRestriction, UserHandle.myUserId()); + } + + /** + * Set the user restriction and disable this preference for the given user. + * + * @param userRestriction constant from {@link android.os.UserManager} + * @param userId user to check the restriction for. + */ + public void checkRestrictionAndSetDisabled(String userRestriction, int userId) { + mHelper.checkRestrictionAndSetDisabled(userRestriction, userId); + } + + @Override + public void setEnabled(boolean enabled) { + if (enabled && isDisabledByAdmin()) { + mHelper.setDisabledByAdmin(/* admin= */ null); + return; + } + super.setEnabled(enabled); + } + + /** + * Check whether this preference is disabled by admin. + * + * @return true if this preference is disabled by admin. + */ + public boolean isDisabledByAdmin() { + return mHelper.isDisabledByAdmin(); + } + + /** + * Disable preference based on the enforce admin. + * + * @param admin details of the admin who enforced the restriction. If it is {@code null}, then + * this preference will be enabled. Otherwise, it will be disabled. + */ + public void setDisabledByAdmin(EnforcedAdmin admin) { + if (mHelper.setDisabledByAdmin(admin)) { + notifyChanged(); + } + } +} diff --git a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedPreferenceHelperTest.java b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedPreferenceHelperTest.java index 1b10c736f266a..f6affb8d2c74d 100644 --- a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedPreferenceHelperTest.java +++ b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedPreferenceHelperTest.java @@ -43,6 +43,8 @@ public class RestrictedPreferenceHelperTest { private Context mContext; @Mock private Preference mPreference; + @Mock + private RestrictedTopLevelPreference mRestrictedTopLevelPreference; private PreferenceViewHolder mViewHolder; private RestrictedPreferenceHelper mHelper; @@ -86,4 +88,21 @@ public class RestrictedPreferenceHelperTest { verify(summaryView).setText(null); verify(summaryView, never()).setVisibility(View.GONE); } + + @Test + public void setDisabledByAdmin_RestrictedPreference_shouldDisablePreference() { + mHelper.setDisabledByAdmin(new RestrictedLockUtils.EnforcedAdmin()); + + verify(mPreference).setEnabled(false); + } + + @Test + public void setDisabledByAdmin_TopLevelRestrictedPreference_shouldNotDisablePreference() { + mHelper = new RestrictedPreferenceHelper(mContext, + mRestrictedTopLevelPreference, /* attrs= */ null); + + mHelper.setDisabledByAdmin(new RestrictedLockUtils.EnforcedAdmin()); + + verify(mRestrictedTopLevelPreference, never()).setEnabled(false); + } } diff --git a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedTopLevelPreferenceTest.java b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedTopLevelPreferenceTest.java new file mode 100644 index 0000000000000..f97ef4a5b8292 --- /dev/null +++ b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/RestrictedTopLevelPreferenceTest.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settingslib; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; +import org.robolectric.util.ReflectionHelpers; + +@RunWith(RobolectricTestRunner.class) +public class RestrictedTopLevelPreferenceTest { + + private Context mContext; + private RestrictedTopLevelPreference mPreference; + private RestrictedPreferenceHelper mHelper; + + @Before + public void setUp() { + mContext = RuntimeEnvironment.application; + mPreference = spy(new RestrictedTopLevelPreference(mContext)); + mHelper = spy(new RestrictedPreferenceHelper(mContext, mPreference, null)); + ReflectionHelpers.setField(mPreference, "mHelper", mHelper); + } + + @Test + public void setEnabled_disabledByAdmin_shouldCallSetDisabledByAdmin() { + when(mHelper.isDisabledByAdmin()).thenReturn(true); + + mPreference.setEnabled(true); + + verify(mHelper).setDisabledByAdmin(any()); + } + + @Test + public void setEnabled_notDisabledByAdmin_shouldNotCallSetDisabledByAdmin() { + when(mHelper.isDisabledByAdmin()).thenReturn(false); + + mPreference.setEnabled(true); + + verify(mHelper, never()).setDisabledByAdmin(any()); + } + + @Test + public void setDisabledByAdmin_shouldNotCallSetEnabled() { + mPreference.setDisabledByAdmin(new RestrictedLockUtils.EnforcedAdmin()); + + verify(mPreference, never()).setEnabled(anyBoolean()); + } +}